@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/src/conventions.ts

@@ -8,7 +8,6 @@
 
 import {
   isArrayLiteralExpression,
-  isAsExpression,
   isBinaryExpression,
   isCallExpression,
   isClassDeclaration,
@@ -22,27 +21,20 @@ import {
   isNamedExports,
   isNamespaceImport,
   isNoSubstitutionTemplateLiteral,
-  isNonNullExpression,
   isNumericLiteral,
   isObjectBindingPattern,
   isObjectLiteralExpression,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isPropertyAssignment,
-  isSatisfiesExpression,
   isShorthandPropertyAssignment,
   isSpreadAssignment,
   isStringLiteral,
   isVariableStatement,
   SyntaxKind,
-  type AsExpression,
   type Identifier,
   type Node,
   type ObjectBindingPattern,
-  type NonNullExpression,
   type ObjectLiteralExpression,
-  type ParenthesizedExpression,
-  type SatisfiesExpression,
   type SourceFile,
 } from "@typescript/native/ast";
 import { lineOf } from "./component-files.ts";
@@ -51,19 +43,34 @@ import {
   type ConventionRow,
   type DirectoryMove,
   type HelperReading,
+  type ManifestEntryKey,
   type MoveReading,
   type OptionsCall,
   type PackageKey,
+  type PrefixedNameReading,
   type ShortNameReading,
   type TestFileReading,
 } from "./convention-rows.ts";
 import { documentStrings } from "./configuration-files.ts";
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
-import type { SetupFailure } from "./setup-failure.ts";
+import {
+  ancestors,
+  dirnamePath,
+  joinPath,
+  normalizePath,
+  relativePath,
+  resolvePath,
+} from "./paths.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 { DEPENDENCY_SECTIONS, INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.ts";
+import { globExpression } from "./text/glob.ts";
+import { yamlDocument } from "./text/yaml.ts";
 
 /** One manifest the analysis reads. */
 export interface ConventionManifest {
@@ -108,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. */
@@ -149,30 +156,19 @@ type ParseSource = (fileName: string, text: string) => SourceFile;
 
 const JSON_EXTENSION = ".json";
 
+/**
+ * A configuration file its tool reads as a YAML document, read as the JSON document it
+ * denotes. Its nodes' offsets are that JSON text's, so no move may read one: a failure's
+ * line would name the wrong line.
+ */
+const YAML_NAME = /\.ya?ml$/u;
+
 /** A configuration file with no extension that its tool reads as a JSON document. */
 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 isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function readJSON(host: Host, path: string): unknown {
-  try {
-    return JSON.parse(host.readFile(path));
-  } catch {
-    return undefined;
-  }
-}
-
 function declares(
   manifest: unknown,
   name: string,
@@ -193,38 +189,15 @@ function declares(
  * none, or `undefined` where no `node_modules` holds it.
  */
 function installedVersion(host: Host, dir: string, name: string): string | undefined {
-  for (let at = normalizePath(dir); ; at = dirnamePath(at)) {
-    const path = joinPath(at, "node_modules", name, "package.json");
+  for (const at of ancestors(dir)) {
+    const path = joinPath(at, INSTALLED_PACKAGES, name, MANIFEST);
     if (host.kindOf(path) === "file") {
       const manifest = readJSON(host, path);
       const version = isRecord(manifest) ? manifest["version"] : undefined;
       return typeof version === "string" ? version : "";
     }
-    if (dirnamePath(at) === at) {
-      return undefined;
-    }
-  }
-}
-
-/** Whether one node wraps an expression without changing its value. */
-function isWrapper(
-  node: Node,
-): node is ParenthesizedExpression | AsExpression | SatisfiesExpression | NonNullExpression {
-  return (
-    isParenthesizedExpression(node) ||
-    isAsExpression(node) ||
-    isSatisfiesExpression(node) ||
-    isNonNullExpression(node)
-  );
-}
-
-/** The expression a wrapper that changes no value holds. */
-function unwrapped(node: Node): Node {
-  let at = node;
-  while (isWrapper(at)) {
-    at = at.expression;
   }
-  return at;
+  return undefined;
 }
 
 /** The key one property is written with, where it is written as a name or as literal text. */
@@ -692,6 +665,47 @@ function manifestKeyUses(manifest: unknown, keys: readonly string[]): readonly s
   );
 }
 
+/** The extensions an entry a manifest entry key names without one may carry. */
+const ENTRY_EXTENSIONS = "{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
+
+/** The characters that make a manifest string a pattern rather than a directory's name. */
+const PATTERN = /[*?{}[\]]/u;
+
+/**
+ * The entry globs one applied row's manifest entry keys write, below the manifest's
+ * directory: a directory's every module, or a file with or without an extension. A string
+ * that leaves the directory names nothing.
+ */
+function manifestEntryGlobs(manifest: unknown, keys: readonly ManifestEntryKey[]): string[] {
+  const at = (value: unknown, path: readonly string[]): unknown[] => {
+    const [key, ...rest] = path;
+    if (key === undefined) {
+      return [value];
+    }
+    if (!isRecord(value)) {
+      return [];
+    }
+    const next = key === "*" ? Object.values(value) : Object.hasOwn(value, key) ? [value[key]] : [];
+    return next.flatMap((one) => at(one, rest));
+  };
+  return keys.flatMap(({ key, directory }) =>
+    at(manifest, key.split(".")).flatMap((value) =>
+      documentStrings(value).flatMap((text) => {
+        const path = normalizePath(text)
+          .replace(/^(?:\.\/)+/u, "")
+          .replace(/\/+$/u, "");
+        if (path === "" || path === ".." || path.startsWith("../") || path.startsWith("/")) {
+          return [];
+        }
+        if (!directory) {
+          return [path, `${path}.${ENTRY_EXTENSIONS}`];
+        }
+        return PATTERN.test(path) ? [] : [`${path}/**/*.${ENTRY_EXTENSIONS}`];
+      }),
+    ),
+  );
+}
+
 /** What one configuration file states about one property. */
 interface PropertyReading {
   /** The literal values the file sets the property to. */
@@ -772,16 +786,7 @@ function expand(
 /** The configuration files in one directory that one glob names, by name. */
 function configurationFiles(host: Host, dir: string, glob: string): readonly string[] {
   const expression = globExpression(glob);
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  return entries
-    .filter((entry) => !entry.directory && expression.test(entry.name))
-    .map((entry) => entry.name)
-    .sort();
+  return filesIn(host, dir, (name) => expression.test(name));
 }
 
 /** What one move resolved to: its directories, or the failure its property met. */
@@ -840,6 +845,14 @@ function readingFiles(
       } catch {
         continue;
       }
+      if (YAML_NAME.test(name)) {
+        const value = yamlDocument(text);
+        if (value !== undefined) {
+          const json = JSON.stringify(value);
+          found.push({ name, text: json, file: parse(`${path}${JSON_EXTENSION}`, json) });
+        }
+        continue;
+      }
       found.push({
         name,
         text,
@@ -889,7 +902,67 @@ function shortNameUses(
       }
     }
   }
-  return [...used].filter((name) => declared.has(name)).sort(compare);
+  return [...used].filter((name) => declared.has(name)).sort(bytewise);
+}
+
+/**
+ * The package one value of a prefixed-name reading names, or none: ESLint's own naming,
+ * https://github.com/eslint/eslintrc/blob/main/lib/shared/naming.js
+ */
+function prefixedPackage(value: string, reading: PrefixedNameReading): string | undefined {
+  const { prefix, marker } = reading;
+  let name: string;
+  if (marker === undefined) {
+    if (value.includes(":") || value.startsWith(".") || value.startsWith("/")) {
+      return undefined;
+    }
+    const parts = value.split("/");
+    name = (value.startsWith("@") ? parts.slice(0, 2) : parts.slice(0, 1)).join("/");
+  } else {
+    if (!value.startsWith(marker) || !value.includes("/", marker.length)) {
+      return undefined;
+    }
+    name = value.slice(marker.length, value.lastIndexOf("/"));
+  }
+  if (name === "") {
+    return undefined;
+  }
+  if (!name.startsWith("@")) {
+    return name.startsWith(`${prefix}-`) ? name : `${prefix}-${name}`;
+  }
+  const [scope, rest] = name.split("/");
+  if (rest === undefined || rest === "" || rest === prefix) {
+    return `${scope ?? name}/${prefix}`;
+  }
+  return rest.startsWith(`${prefix}-`) ? name : `${scope ?? name}/${prefix}-${rest}`;
+}
+
+/** The declared dependencies an applied row's prefixed names use. */
+function prefixedNameUses(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  manifest: unknown,
+  readings: readonly PrefixedNameReading[],
+): readonly string[] {
+  const declared = new Set(
+    DEPENDENCY_SECTIONS.flatMap((section) => {
+      const held = isRecord(manifest) ? manifest[section] : undefined;
+      return isRecord(held) ? Object.keys(held) : [];
+    }),
+  );
+  const used = new Set<string>();
+  for (const reading of readings) {
+    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+      for (const value of readProperty(file, reading.property, reading.call, true).values) {
+        const named = prefixedPackage(value, reading);
+        if (named !== undefined && declared.has(named)) {
+          used.add(named);
+        }
+      }
+    }
+  }
+  return [...used].sort(bytewise);
 }
 
 /** The declared dependencies an applied row's helper settings use. */
@@ -973,14 +1046,6 @@ function packageKeyUses(
   );
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * What the rows decide over the manifests the analysis reads. A row `disabled` names
  * is skipped before anything is read for it.
@@ -1000,7 +1065,7 @@ export function readConventions(
   const selected = new Map<string, { starts: Set<number>; texts: string[] }>();
   const testFiles = new Set<string>();
   for (const manifest of manifests) {
-    const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
+    const declared = readJSON(host, joinPath(manifest.dir, MANIFEST));
     const versions = new Map<string, string | undefined>();
     const missing = new Set<string>();
     for (const row of rows) {
@@ -1023,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`,
@@ -1049,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}`,
           },
         });
@@ -1064,6 +1129,10 @@ export function readConventions(
       for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
         uses.add(name);
       }
+      const prefixed = row.prefixedNames ?? [];
+      for (const name of prefixedNameUses(host, parse, manifest.dir, declared, prefixed)) {
+        uses.add(name);
+      }
       const keys = row.packageKeys ?? [];
       for (const name of packageKeyUses(host, parse, manifest.dir, declared, keys)) {
         uses.add(name);
@@ -1082,7 +1151,11 @@ export function readConventions(
       for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
         generated.push({ dir: manifest.dir, row: row.name, below });
       }
-      for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
+      const written = [
+        ...row.entries.flatMap((entry) => expand(entry, resolved)),
+        ...manifestEntryGlobs(declared, row.manifestEntries ?? []),
+      ];
+      for (const glob of new Set(written)) {
         globs.push({
           dir: manifest.dir,
           row: row.name,
@@ -1095,16 +1168,16 @@ export function readConventions(
   const unique = [...new Map(applied.map((one) => [JSON.stringify(one), one])).values()];
   unique.sort(
     (a, b) =>
-      compare(a.name, b.name) ||
-      compare(a.manifest, b.manifest) ||
-      compare(JSON.stringify(a), JSON.stringify(b)),
+      bytewise(a.name, b.name) ||
+      bytewise(a.manifest, b.manifest) ||
+      bytewise(JSON.stringify(a), JSON.stringify(b)),
   );
   return {
     applied: unique,
     globs,
     generated,
     failures,
-    uses: [...uses].sort(compare),
+    uses: [...uses].sort(bytewise),
     selected,
     testFiles,
   };
@@ -1138,12 +1211,15 @@ export function conventionEntries(
   const found = new Map<string, ConventionEntry>();
   for (const glob of conventions.globs) {
     for (const file of files.byName.values()) {
-      const path = relativePath(glob.dir, file.fileName);
-      if (
-        path !== undefined &&
-        glob.expression.test(path) &&
-        !glob.excludes.some((one) => one.test(path))
-      ) {
+      const matched = [file.fileName, ...files.writtenAs(file)].some((name) => {
+        const path = relativePath(glob.dir, name);
+        return (
+          path !== undefined &&
+          glob.expression.test(path) &&
+          !glob.excludes.some((one) => one.test(path))
+        );
+      });
+      if (matched) {
         found.set(`${file.fileName}\u0000${glob.row}`, { file, row: glob.row });
       }
     }
@@ -1159,7 +1235,7 @@ export function conventionFailuresFor(
   conventions: Conventions,
   configFile: string,
   ownFiles: readonly string[],
-): readonly SetupFailure[] {
+): readonly Failure[] {
   return conventions.failures
     .filter(
       ({ dir }) =>

package/src/decorator.ts

@@ -1,14 +1,10 @@
 /**
- * The decorator class: a member a decorator expression is attached to, and every
- * member of a class a decorator expression is attached to, is held back, because the
- * decorator receives the member or the class when the class is defined and may reach
- * the member by its name.
- *
- * The rule is read from the tree alone: a decorator is attached where it is written.
- * The use the decorator itself makes of what it decorates is the reference pass's,
- * which records it as a `decorator` reference; this class records only that the
- * declaration is held back, and the member set of a decorated class is every member
- * the inventory holds for the class, static members included.
+ * The decorator class: a member a decorator expression is attached to, and every member
+ * of a class one is attached to but the member a parameter property declares, is held
+ * back, because the decorator may reach the member by its name. The rule is read from
+ * the tree alone. The decorator's own use of what it decorates is the reference pass's
+ * `decorator` reference; this class records only that the declaration is held back,
+ * static members of a decorated class included.
  */
 
 import type { Node } from "@typescript/native/ast";
@@ -44,25 +40,39 @@ export function decorator<Brand>(input: DetectorInput<Brand>): readonly Evidence
     }
   }
 
-  const found: Evidence[] = [];
+  const decorated: {
+    readonly symbol: InventorySymbol;
+    readonly detail: string;
+    readonly site: Evidence["site"];
+  }[] = [];
+  // A decorated class's container passes each constructor argument, which keeps the
+  // parameter, not the member a parameter property stores it in.
+  const parameterMembers = new Set<string>();
   for (const file of project.ownSourceFiles()) {
     const visit = (node: Node): void => {
       const id = held.declarations.get(nodeKey(file, node));
       const symbol = id === undefined ? undefined : byId.get(id);
+      if (id !== undefined && isParameterProperty(node)) {
+        parameterMembers.add(id);
+      }
       // A parameter property's decorator is attached to its parameter, and to no member.
       if (symbol !== undefined && DECORATED.has(symbol.kind) && !isParameterProperty(node)) {
         for (const attached of decoratorsOf(node)) {
-          const detail = `decorated by ${spelledDecorator(attached)}`;
-          const site = renderPosition(file, targetRoot, attached.getStart());
-          const reached = symbol.kind === "class" ? (membersOf.get(symbol.id) ?? []) : [symbol];
-          for (const member of reached) {
-            found.push({ id: member.id, detail, site });
-          }
+          decorated.push({
+            symbol,
+            detail: `decorated by ${spelledDecorator(attached)}`,
+            site: renderPosition(file, targetRoot, attached.getStart()),
+          });
         }
       }
       node.forEachChild(visit);
     };
     file.forEachChild(visit);
   }
-  return found;
+  return decorated.flatMap(({ symbol, detail, site }) =>
+    (symbol.kind === "class"
+      ? (membersOf.get(symbol.id) ?? []).filter((member) => !parameterMembers.has(member.id))
+      : [symbol]
+    ).map((member) => ({ id: member.id, detail, site })),
+  );
 }