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

package/src/fs/tree.ts

@@ -0,0 +1,110 @@
+import type { DirectoryEntry, Host } from "../host.ts";
+import { ancestors, joinPath, resolvePath } from "../paths.ts";
+import { LANGUAGE_ROWS } from "../contract/contract.generated.ts";
+import { LANGUAGE } from "../product.ts";
+import { bytewise } from "../text/compare.ts";
+import { globExpression } from "../text/glob.ts";
+
+/** The directories no walk of the tree enters, by the patterns the language's row names. */
+const SKIPPED_DIRECTORIES = LANGUAGE_ROWS[LANGUAGE].skippedDirectories.map(globExpression);
+
+function skipped(name: string): boolean {
+  return SKIPPED_DIRECTORIES.some((pattern) => pattern.test(name));
+}
+
+/** A git repository's working tree root, and the `info/exclude` file git reads for it. */
+interface Repository {
+  readonly root: string;
+  /** Undefined where a `.git` file names no repository directory. */
+  readonly exclude: string | undefined;
+}
+
+/** One file's text without its line ending, or undefined where it cannot be read. */
+function lineOf(host: Host, path: string): string | undefined {
+  try {
+    return host.readFile(path).replace(/\r?\n$/u, "");
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The repository whose working tree holds `dir`: the nearest directory at or above it with a
+ * `.git`. A `.git` file, which a linked worktree or a submodule holds, names the repository's
+ * directory on its `gitdir:` line; that directory's `commondir` file, where it has one, names
+ * the directory shared with the main worktree, which holds `info/exclude`:
+ * https://git-scm.com/docs/gitrepository-layout
+ */
+export function repositoryOf(host: Host, dir: string): Repository | undefined {
+  for (const root of ancestors(dir)) {
+    const dotGit = joinPath(root, ".git");
+    const kind = host.kindOf(dotGit);
+    if (kind === "directory") {
+      return { root, exclude: joinPath(dotGit, "info/exclude") };
+    }
+    if (kind === "file") {
+      const named = /^gitdir: (.+)$/u.exec(lineOf(host, dotGit) ?? "")?.[1];
+      const gitDir = named === undefined ? undefined : resolvePath(root, named);
+      const common = gitDir === undefined ? undefined : lineOf(host, joinPath(gitDir, "commondir"));
+      const shared =
+        gitDir === undefined || common === undefined ? gitDir : resolvePath(gitDir, common);
+      return { root, exclude: shared === undefined ? undefined : joinPath(shared, "info/exclude") };
+    }
+  }
+  return undefined;
+}
+
+/** The entries of one directory, none where it cannot be read. */
+export function entriesOf(host: Host, dir: string): readonly DirectoryEntry[] {
+  try {
+    return host.readDirectory(dir);
+  } catch {
+    return [];
+  }
+}
+
+/** The names of the files directly in `dir` whose name `accepts`, in bytewise order. */
+export function filesIn(
+  host: Host,
+  dir: string,
+  accepts: (name: string) => boolean,
+): readonly string[] {
+  return entriesOf(host, dir)
+    .filter((entry) => !entry.directory && accepts(entry.name))
+    .map((entry) => entry.name)
+    .sort(bytewise);
+}
+
+/** The names of the directories directly in `dir` a walk enters, in bytewise order. */
+export function directoriesIn(host: Host, dir: string): readonly string[] {
+  return entriesOf(host, dir)
+    .filter((entry) => entry.directory && !skipped(entry.name))
+    .map((entry) => entry.name)
+    .sort(bytewise);
+}
+
+/**
+ * Every file below `root` whose name `accepts`, by its path relative to `root` in bytewise
+ * order, read in no skipped directory.
+ */
+export function filesBelow(
+  host: Host,
+  root: string,
+  accepts: (name: string) => boolean,
+): readonly string[] {
+  const found: string[] = [];
+  const pending = [""];
+  for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
+    for (const entry of entriesOf(host, joinPath(root, dir))) {
+      const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+      if (!entry.directory) {
+        if (accepts(entry.name)) {
+          found.push(path);
+        }
+      } else if (!skipped(entry.name)) {
+        pending.push(path);
+      }
+    }
+  }
+  return found.sort(bytewise);
+}

package/src/git-ignore.ts

@@ -1,13 +1,14 @@
 /**
- * Which files the `.gitignore` files of a tree ignore, read as git reads them:
+ * Which files git ignores below a tree's root, read as git reads its ignore files:
  * https://git-scm.com/docs/gitignore#_pattern_format
  */
 
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.ts";
+import { gitignoreExpression } from "./text/glob.ts";
+import { repositoryOf } from "./fs/tree.ts";
 
-/** One pattern line of a `.gitignore` file. */
+/** One pattern line of an ignore file. */
 interface Rule {
   readonly negated: boolean;
   /** Whether the pattern ends with `/`, so it matches a directory alone. */
@@ -16,7 +17,7 @@ interface Rule {
   readonly expression: RegExp;
 }
 
-/** The rules one `.gitignore` text writes, in order. */
+/** The rules one ignore file's text writes, in order. */
 function rulesOf(text: string): readonly Rule[] {
   const rules: Rule[] = [];
   for (const raw of text.split(/\r?\n/u)) {
@@ -25,7 +26,7 @@ function rulesOf(text: string): readonly Rule[] {
       continue;
     }
     const negated = line.startsWith("!");
-    line = negated || line.startsWith("\\") ? line.slice(1) : line;
+    line = negated ? line.slice(1) : line;
     const directoryOnly = line.endsWith("/");
     line = line.replace(/\/+$/u, "");
     if (line === "") {
@@ -38,43 +39,55 @@ function rulesOf(text: string): readonly Rule[] {
     rules.push({
       negated,
       directoryOnly,
-      expression: globExpression(anchored ? pattern : `**/${pattern}`),
+      expression: gitignoreExpression(anchored ? pattern : `**/${pattern}`),
     });
   }
   return rules;
 }
 
+function rulesIn(host: Host, path: string): readonly Rule[] {
+  try {
+    return rulesOf(host.readFile(path));
+  } catch {
+    return [];
+  }
+}
+
 /**
- * Whether the `.gitignore` files at and below `root` ignore one absolute path. A path
- * outside `root` is not ignored, and a file below an ignored directory stays ignored
- * whatever a later pattern says, as git cannot re-include it.
+ * Whether git ignores one absolute path below `root`: by the repository's `info/exclude`,
+ * then the `.gitignore` files from the repository's root down to the path's directory, a
+ * later pattern overriding an earlier one. A path outside `root` is not ignored, and a file
+ * below an ignored directory stays ignored whatever a later pattern says, as git cannot
+ * re-include it. With no repository at or above `root`, the files at and below it are read;
+ * with one, the directories above `root` give patterns but are not themselves tested.
  */
 export function gitIgnored(host: Host, root: string): (path: string) => boolean {
+  const found = repositoryOf(host, root);
+  const repository = found?.root;
+  const above =
+    repository === undefined ? [] : [...ancestors(dirnamePath(root), repository)].reverse();
+  const excluded = found?.exclude === undefined ? [] : rulesIn(host, found.exclude);
   const read = new Map<string, readonly Rule[]>();
   const rulesAt = (dir: string): readonly Rule[] => {
     let rules = read.get(dir);
     if (rules === undefined) {
-      try {
-        rules = rulesOf(host.readFile(joinPath(dir, ".gitignore")));
-      } catch {
-        rules = [];
-      }
+      rules = rulesIn(host, joinPath(dir, ".gitignore"));
       read.set(dir, rules);
     }
     return rules;
   };
-  /** Whether the rules of `root` and of each directory down to one path's own decide it ignored. */
   const decided = (path: string, directory: boolean): boolean => {
-    const dirs: string[] = [];
-    for (let at = dirnamePath(path); relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-      dirs.unshift(at);
-    }
-    dirs.unshift(root);
+    const sources: [string, readonly Rule[]][] = [
+      ...(repository === undefined ? [] : [[repository, excluded] as [string, readonly Rule[]]]),
+      ...[...above, ...[...ancestors(dirnamePath(path), root)].reverse()].map(
+        (dir): [string, readonly Rule[]] => [dir, rulesAt(dir)],
+      ),
+    ];
     let ignored = false;
-    for (const dir of dirs) {
-      const below = relativePath(dir, path);
-      for (const rule of below === undefined ? [] : rulesAt(dir)) {
-        if ((directory || !rule.directoryOnly) && rule.expression.test(below ?? "")) {
+    for (const [dir, rules] of sources) {
+      const below = relativePath(dir, path) ?? "";
+      for (const rule of rules) {
+        if ((directory || !rule.directoryOnly) && rule.expression.test(below)) {
           ignored = !rule.negated;
         }
       }

package/src/html-entries.ts

@@ -12,8 +12,10 @@ import {
 } from "@typescript/native/ast";
 import { resolveRelativeSpecifier, type ParseFile } from "./configuration-files.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { filesBelow } from "./fs/tree.ts";
+import { holdsManifest } from "./fs/manifest.ts";
 
 /** One file a script loads, and the value or specifier that named it. */
 interface HTMLEntry {
@@ -21,9 +23,6 @@ interface HTMLEntry {
   readonly source: string;
 }
 
-/** The directory no HTML file is read below. */
-const SKIPPED = "node_modules";
-
 /** A `<script` start tag, its attribute text captured. */
 const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 
@@ -42,28 +41,6 @@ const CLASSIC_TYPES: ReadonlySet<string> = new Set(["text/javascript", "applicat
 /** The prefixes an inline script's specifier names a file of the target with. */
 const FILE_PREFIXES = ["/", "./", "../"] as const;
 
-/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
-function htmlFiles(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 (entry.name !== SKIPPED) {
-        found.push(...htmlFiles(host, path));
-      }
-    } else if (entry.name.endsWith(".html")) {
-      found.push(path);
-    }
-  }
-  return found.sort();
-}
-
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text: string): ReadonlyMap<string, string> {
   const found = new Map<string, string>();
@@ -127,12 +104,7 @@ function scriptValues(parse: ParseFile | undefined, path: string, text: string):
 
 /** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
 function manifestDirectory(host: Host, root: string, dir: string): string {
-  for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-    if (host.kindOf(joinPath(at, "package.json")) === "file") {
-      return at;
-    }
-  }
-  return root;
+  return ancestors(dir, root).find((at) => holdsManifest(host, at)) ?? root;
 }
 
 /**
@@ -150,7 +122,8 @@ export function htmlEntries(
 ): readonly HTMLEntry[] {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const found: HTMLEntry[] = [];
-  for (const path of htmlFiles(host, root)) {
+  for (const below of filesBelow(host, root, (name) => name.endsWith(".html"))) {
+    const path = joinPath(root, below);
     let text: string;
     try {
       text = host.readFile(path);

package/src/in-operands.ts

@@ -13,6 +13,7 @@ import {
 } from "@typescript/native/ast";
 import type { ProjectView } from "./session.ts";
 import { sourceFilesOf } from "./source-files.ts";
+import { bytewise } from "./text/compare.ts";
 
 /**
  * The text of each string literal, or template literal with no substitution, written as
@@ -41,5 +42,5 @@ export function inOperandNames<Brand>(
       file.forEachChild(visit);
     }
   }
-  return [...found].sort();
+  return [...found].sort(bytewise);
 }

package/src/index.ts

@@ -19,4 +19,4 @@ export {
   type Fragment,
   type Module,
 } from "./ref.ts";
-export { CONTRACT_VERSION } from "./version.ts";
+export { CONTRACT_VERSION } from "./contract/contract.generated.ts";

package/src/intra-function-parts.ts

@@ -5,6 +5,7 @@
  * write to a local that no read reaches, and each case an earlier case covers.
  */
 
+import { CODE } from "./contract/contract.generated.ts";
 import {
   isArrowFunction,
   isAwaitExpression,
@@ -95,6 +96,7 @@ import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 import { signatureOf, type SignatureNode } from "./signatures.ts";
 import { spellsNoBinding } from "./spelled-names.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
 
 /** The subject kind of each part this module reads. */
 type PartKind = "parameter" | "result" | "statement" | "store" | "case";
@@ -179,13 +181,6 @@ export interface ProjectParts {
   readonly constructions: ReadonlySet<string>;
 }
 
-/** The codes of the parts this module reads. */
-export const UNUSED_PARAMETER = "DS1801";
-export const UNUSED_RESULT = "DS1803";
-const UNREACHABLE_STATEMENT = "DS1805";
-const DEAD_STORE = "DS1807";
-const UNREACHABLE_CASE = "DS1809";
-
 /** The result types that carry no value, as the checker spells them. */
 const NO_VALUE: ReadonlySet<string> = new Set([
   "void",
@@ -203,11 +198,6 @@ function spanOf(file: SourceFile, root: string, node: Node): FindingPosition {
   return { ...start, endLine };
 }
 
-/** The parenthesized expression's content, through every pair of parentheses. */
-function unwrapped(node: Node): Node {
-  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
-
 /** The node the parentheses around one expression sit in. */
 function outerParent(node: Node): Node {
   return isParenthesizedExpression(node.parent) ? outerParent(node.parent) : node.parent;
@@ -215,7 +205,7 @@ function outerParent(node: Node): Node {
 
 /** The name a call is made through: the identifier, or the member a property access names. */
 function calleeName(call: CallExpression): Identifier | undefined {
-  const callee = unwrapped(call.expression);
+  const callee = parenthesesRemoved(call.expression);
   if (isIdentifier(callee)) {
     return callee;
   }
@@ -282,7 +272,7 @@ function unreachableExempt(statement: Statement): boolean {
 
 /** The value a case expression is a literal of, as a key two equal literals share, or none. */
 function caseKey(expression: Node): string | undefined {
-  const node = unwrapped(expression);
+  const node = parenthesesRemoved(expression);
   if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
     return `s:${node.text}`;
   }
@@ -408,7 +398,7 @@ function extendedNames(files: readonly SourceFile[]): ReadonlySet<string> {
         if (isTypeReferenceNode(type)) {
           named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
         } else {
-          const expression = unwrapped(type.expression);
+          const expression = parenthesesRemoved(type.expression);
           named = isPropertyAccessExpression(expression) ? expression.name : expression;
         }
         if (isIdentifier(named)) {
@@ -461,7 +451,7 @@ function decoratorFixes(constructor: ConstructorDeclaration): boolean {
 
 /** The name an expression spells a class by: an identifier, or the member a property access names. */
 function spelledName(expression: Node): Identifier | undefined {
-  const node = unwrapped(expression);
+  const node = parenthesesRemoved(expression);
   if (isIdentifier(node)) {
     return node;
   }
@@ -730,8 +720,8 @@ export function projectParts<Brand>(
       if ((isImportClause(node) || isNamespaceImport(node)) && node.name !== undefined) {
         specifiers.add(position(node.name));
       }
-      if (isExportAssignment(node) && isIdentifier(unwrapped(node.expression))) {
-        specifiers.add(position(unwrapped(node.expression)));
+      if (isExportAssignment(node) && isIdentifier(parenthesesRemoved(node.expression))) {
+        specifiers.add(position(parenthesesRemoved(node.expression)));
       }
       if (isSwitchStatement(node)) {
         const holder = holderOf(node);
@@ -869,7 +859,7 @@ export function projectParts<Brand>(
     }
     walk.catches.forEach(({ name, holder }, at) => {
       parts.push({
-        code: DEAD_STORE,
+        code: CODE.deadStore,
         declaration: holder,
         kind: "store",
         name: name.text,
@@ -881,7 +871,7 @@ export function projectParts<Brand>(
     for (const { names, uses, holder } of loopVariables) {
       for (const name of names) {
         parts.push({
-          code: DEAD_STORE,
+          code: CODE.deadStore,
           declaration: holder,
           kind: "store",
           name: name.text,
@@ -899,7 +889,7 @@ export function projectParts<Brand>(
     });
     for (const { statement, holder } of walk.unreachable) {
       parts.push({
-        code: UNREACHABLE_STATEMENT,
+        code: CODE.unreachableStatement,
         declaration: holder,
         kind: "statement",
         name: "statement",
@@ -910,7 +900,7 @@ export function projectParts<Brand>(
     }
     for (const { clause, text, holder } of walk.cases) {
       parts.push({
-        code: UNREACHABLE_CASE,
+        code: CODE.unreachableCase,
         declaration: holder,
         kind: "case",
         name: text,
@@ -1176,7 +1166,7 @@ function parameterParts(
       return;
     }
     const part: PartFact = {
-      code: UNUSED_PARAMETER,
+      code: CODE.unusedParameter,
       declaration,
       kind: "parameter",
       name: name.text,
@@ -1331,7 +1321,7 @@ function isPlainWrite(use: Identifier): boolean {
   return (
     isBinaryExpression(parent) &&
     parent.operatorToken.kind === SyntaxKind.EqualsToken &&
-    unwrapped(parent.left) === use
+    parenthesesRemoved(parent.left) === use
   );
 }
 
@@ -1353,7 +1343,7 @@ function deadStores(
 ): PartFact[] {
   const found: PartFact[] = [];
   const deadAt = (local: Local, target: Identifier): PartFact => ({
-    code: DEAD_STORE,
+    code: CODE.deadStore,
     declaration: holder,
     kind: "store",
     name: local.name.text,
@@ -1388,14 +1378,14 @@ function deadStores(
       if (!isExpressionStatement(statement)) {
         return undefined;
       }
-      const expression = unwrapped(statement.expression);
+      const expression = parenthesesRemoved(statement.expression);
       if (
         !isBinaryExpression(expression) ||
         expression.operatorToken.kind !== SyntaxKind.EqualsToken
       ) {
         return undefined;
       }
-      const target = unwrapped(expression.left);
+      const target = parenthesesRemoved(expression.left);
       return isIdentifier(target) && uses.includes(target)
         ? { target, value: expression.right }
         : undefined;
@@ -1482,7 +1472,7 @@ function resultParts<Brand>(
     const valued = project.queries.nonNullable(result);
     const members = isAnswered(valued) ? project.queries.propertiesOf(valued) : UNANSWERED;
     found.push({
-      code: UNUSED_RESULT,
+      code: CODE.unusedResult,
       declaration: id,
       kind: "result",
       name: "result",

package/src/inventory.ts

@@ -50,6 +50,7 @@ import {
 import { computedComponent, nameComponent, renderRef, type Component, type Module } from "./ref.ts";
 import { isAnswered, UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
+import { manifestAt } from "./fs/manifest.ts";
 
 /**
  * The symbol inventory of one project: every declaration the target's own files
@@ -233,8 +234,6 @@ interface ExportScope {
   readonly nameNode: Node;
 }
 
-const MANIFEST = "package.json";
-
 /** One manifest that names a package, and the directory below the root that holds it. */
 interface Named {
   readonly name: string;
@@ -255,24 +254,7 @@ export function packageScope(host: Host, root: string): (path: string) => Module
   const named = new Map<string, Named | undefined>();
 
   const manifestName = (dir: string): string | undefined => {
-    let text: string;
-    try {
-      text = host.readFile(joinPath(root, dir, MANIFEST));
-    } catch {
-      return undefined;
-    }
-    let value: unknown;
-    try {
-      value = JSON.parse(text);
-    } catch {
-      // A manifest this program cannot read names no package, which is the same
-      // answer as an absent one: the file is then scoped by the target root.
-      return undefined;
-    }
-    if (typeof value !== "object" || value === null) {
-      return undefined;
-    }
-    const name = (value as Record<string, unknown>)["name"];
+    const name = manifestAt(host, joinPath(root, dir))?.["name"];
     return typeof name === "string" && name !== "" ? name : undefined;
   };
 

package/src/json-document.ts

@@ -128,3 +128,8 @@ export function positionAt(text: string, file: string, offset: number): Position
   const lineStart = before.lastIndexOf("\n") + 1;
   return { path: file, line: before.split("\n").length, column: offset - lineStart + 1 };
 }
+
+/** Whether a decoded JSON value is an object: not `null` and not an array. */
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/keyof-comparisons.ts

@@ -10,7 +10,6 @@ import {
   isCaseClause,
   isElementAccessExpression,
   isIdentifier,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isSwitchStatement,
   isTypeOperatorNode,
@@ -27,6 +26,7 @@ import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
 
 /** The operators that compare their operands for equality. */
 const EQUALITIES: ReadonlySet<SyntaxKind> = new Set([
@@ -44,13 +44,9 @@ interface Comparison {
   readonly other: Expression;
 }
 
-function unwrapped(node: Expression): Expression {
-  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
-
 /** The name node an operand's symbol is read at: an identifier, or a property access's name. */
 function nameOf(node: Expression): Node | undefined {
-  const at = unwrapped(node);
+  const at = parenthesesRemoved(node);
   if (isIdentifier(at)) {
     return at;
   }
@@ -132,7 +128,7 @@ export function keyofComparisonReferences<Brand>(
   }
   const named = comparisons.flatMap((one) => {
     const name = nameOf(one.keyed);
-    return name === undefined || isElementAccessExpression(unwrapped(one.other))
+    return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
       ? []
       : [{ ...one, name }];
   });