@cplieger/deadset-ts 6.1.0 → 7.0.0-dev.1

package/dist/src/symbol-keys.js

@@ -0,0 +1,114 @@
+/**
+ * The members a unique symbol keys, used through element accesses. `value[key]`, where
+ * `key` is a constant of a `unique symbol` type, reads the member of the receiver's type
+ * whose computed name is that same constant, and a store through the access writes it.
+ * No name node resolves to such a member: the key's name resolves to the constant.
+ */
+import { isComputedPropertyName, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { isAnswered } from "./query.js";
+/** The identifier an element access's argument names its key by, where it is a name. */
+export function keyNameOf(argument) {
+    let at = argument;
+    while (isParenthesizedExpression(at)) {
+        at = at.expression;
+    }
+    if (isIdentifier(at)) {
+        return at;
+    }
+    return isPropertyAccessExpression(at) && isIdentifier(at.name) ? at.name : undefined;
+}
+/**
+ * The last identifier of each computed member name the inventory holds, `mark` for
+ * `[mark]` and `iterator` for `[Symbol.iterator]`: an access whose key is spelled by no
+ * such identifier selects no member a unique symbol keys, and is not asked about.
+ */
+export function computedKeyNames(symbols) {
+    const names = new Set();
+    for (const symbol of symbols) {
+        const key = /\[([^\]]+)\]$/u.exec(symbol.name)?.[1];
+        const last = key?.split(".").pop()?.trim();
+        if (last !== undefined && /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(last)) {
+            names.add(last);
+        }
+    }
+    return names;
+}
+/** Whether a computed name's expression is literal text, which names a member by its text. */
+function isLiteralKey(expression) {
+    return (isStringLiteral(expression) ||
+        isNumericLiteral(expression) ||
+        isNoSubstitutionTemplateLiteral(expression));
+}
+/**
+ * The members each keyed access selects. The receivers' types are asked in one batch,
+ * each object type's properties once, and the key of every property declared under a
+ * computed name in one batch more; a property is selected where its key and the
+ * access's key are one symbol.
+ */
+export function keyedUses(project, chains, resolved, properties, cap) {
+    if (resolved.length === 0) {
+        return [];
+    }
+    const queries = project.queries;
+    const ownPaths = project.ownPaths();
+    const types = queries.typesAt(resolved.map((one) => one.access.access.expression), cap);
+    const parts = new Map();
+    const partsOf = (type) => {
+        const known = parts.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        let found = [];
+        if (type.isUnionType() || type.isIntersectionType()) {
+            const constituents = queries.constituents(type);
+            found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
+        }
+        else if (type.isObjectType()) {
+            found = [type];
+        }
+        parts.set(type.id, found);
+        return found;
+    };
+    /** Each receiver's properties declared in the target under a computed name, with that name's expression. */
+    const candidates = new Map();
+    const keyNodes = [];
+    const candidatesOf = (type) => {
+        const known = candidates.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = [];
+        const read = properties.of(type);
+        for (const property of isAnswered(read.properties) ? read.properties : []) {
+            const handle = property.declarations.find((one) => ownPaths.has(one.path));
+            const node = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+            const name = node?.name;
+            if (name !== undefined && isComputedPropertyName(name) && !isLiteralKey(name.expression)) {
+                found.push({ property, key: name.expression });
+                keyNodes.push(name.expression);
+            }
+        }
+        candidates.set(type.id, found);
+        return found;
+    };
+    const perAccess = resolved.map((_one, index) => {
+        const type = types[index];
+        return type === undefined || !isAnswered(type) ? [] : partsOf(type).flatMap(candidatesOf);
+    });
+    const keyOf = new Map();
+    const asked = [...new Set(keyNodes)];
+    (asked.length === 0
+        ? []
+        : project.symbolsAt(asked.map((node) => project.handle(node)), cap)).forEach((symbol, index) => {
+        const node = asked[index];
+        if (node !== undefined && symbol !== undefined && isAnswered(symbol)) {
+            keyOf.set(node, symbol.id);
+        }
+    });
+    return resolved.flatMap((one, index) => {
+        const ids = (perAccess[index] ?? [])
+            .filter((candidate) => keyOf.get(candidate.key) === one.symbol.id)
+            .flatMap((candidate) => chains.declarationsOf(candidate.property));
+        return ids.length === 0 ? [] : [{ access: one.access, ids: [...new Set(ids)] }];
+    });
+}

package/dist/src/test-joins.js

@@ -0,0 +1,101 @@
+/**
+ * The test files a derived matrix holds although no configuration's file list names them.
+ * The test runner compiles such a file with the options of the nearest compiler
+ * configuration at or above it, so the file joins that configuration's program as a file
+ * its list names, unless a `package.json` below that configuration's directory makes the
+ * file another package's, which its own test runner compiles.
+ */
+import { sourcePaths } from "./file-facts.js";
+import { dirnamePath, joinPath, relativePath } from "./paths.js";
+import { writtenPath } from "./workspace-programs.js";
+const PREFERRED = "/tsconfig.json";
+/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
+function byPreference(a, b) {
+    const first = a.endsWith(PREFERRED) ? 0 : 1;
+    const second = b.endsWith(PREFERRED) ? 0 : 1;
+    return first - second || (a < b ? -1 : a > b ? 1 : 0);
+}
+/**
+ * Per configuration of `configFiles`, the absolute paths of the test files that join it:
+ * each file below `root` a pattern of `patterns` names, that no configuration's file list
+ * holds, joins the configuration nearest at or above its directory when no `package.json`
+ * sits between them. A configuration the compiler cannot read lists nothing and is joined
+ * by nothing.
+ */
+export function joinedTestFiles(engine, host, root, configFiles, patterns) {
+    const listed = new Set();
+    const byDir = new Map();
+    for (const configFile of configFiles) {
+        let fileNames;
+        try {
+            fileNames = engine.parseConfigFile(configFile).fileNames;
+        }
+        catch {
+            continue;
+        }
+        fileNames.forEach((name) => listed.add(name));
+        const dir = dirnamePath(configFile);
+        byDir.set(dir, [...(byDir.get(dir) ?? []), configFile].sort(byPreference));
+    }
+    const joins = new Map();
+    for (const path of sourcePaths(host, root)) {
+        const file = joinPath(root, path);
+        if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
+            continue;
+        }
+        for (let dir = dirnamePath(file);; dir = dirnamePath(dir)) {
+            const [nearest] = byDir.get(dir) ?? [];
+            if (nearest !== undefined) {
+                joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
+                break;
+            }
+            if (host.kindOf(joinPath(dir, "package.json")) === "file" ||
+                dir === root ||
+                relativePath(root, dir) === undefined) {
+                break;
+            }
+        }
+    }
+    return joins;
+}
+/**
+ * How the snapshot reads each configuration a test file joins: the program `programs`
+ * describes with the files added to its root files, or a configuration only the snapshot
+ * holds that extends the one `programs` writes, or the configuration itself, and lists
+ * every file the configuration lists and the joined ones.
+ */
+export function withJoinedTests(engine, host, programs, joins) {
+    const found = new Map(programs);
+    for (const [configFile, files] of joins) {
+        const program = programs.get(configFile);
+        if (program?.kind === "program") {
+            found.set(configFile, {
+                kind: "program",
+                params: {
+                    ...program.params,
+                    rootFiles: [...(program.params.rootFiles ?? []), ...files],
+                },
+            });
+            continue;
+        }
+        let listed;
+        try {
+            listed =
+                program?.kind === "configuration"
+                    ? engine.parseConfigJson(JSON.parse(program.text), program.file).fileNames
+                    : engine.parseConfigFile(configFile).fileNames;
+        }
+        catch {
+            continue;
+        }
+        const value = program?.kind === "configuration"
+            ? { ...JSON.parse(program.text), files: [...listed, ...files] }
+            : { extends: configFile, files: [...listed, ...files] };
+        found.set(configFile, {
+            kind: "configuration",
+            file: program?.kind === "configuration" ? program.file : writtenPath(host, configFile),
+            text: `${JSON.stringify({ ...value, include: [] }, null, 2)}\n`,
+        });
+    }
+    return found;
+}

package/dist/src/version.js

@@ -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 = "6.1.0";
+export const CONTRACT_VERSION = "7.0.0";

package/dist/src/workflow-steps.js

@@ -50,12 +50,8 @@ export function runCommands(text) {
     }
     return found;
 }
-/**
- * The own files the `run:` steps of every workflow file in the target root's
- * `.github/workflows` name: a token equal to a file's path below the target root, with or
- * without a leading `./`, whatever directory the step runs in.
- */
-export function workflowEntries(host, targetRoot, files) {
+/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
+export function workflowTokens(host, targetRoot) {
     const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
     const found = [];
     for (const path of workflowFiles(host, dir)) {
@@ -67,15 +63,25 @@ export function workflowEntries(host, targetRoot, files) {
             continue;
         }
         for (const command of runCommands(text)) {
-            for (const token of scriptTokens(command)) {
-                if (COMPUTED.test(token)) {
-                    continue;
-                }
-                const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
-                if (file !== undefined) {
-                    found.push({ file, source: token });
-                }
-            }
+            found.push(...scriptTokens(command));
+        }
+    }
+    return found;
+}
+/**
+ * The own files the `run:` steps of every workflow file in the target root's
+ * `.github/workflows` name: a token equal to a file's path below the target root, with or
+ * without a leading `./`, whatever directory the step runs in.
+ */
+export function workflowEntries(host, targetRoot, files) {
+    const found = [];
+    for (const token of workflowTokens(host, targetRoot)) {
+        if (COMPUTED.test(token)) {
+            continue;
+        }
+        const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
+        if (file !== undefined) {
+            found.push({ file, source: token });
         }
     }
     return found;

package/dist/src/workspace-programs.js

@@ -48,7 +48,7 @@ function unstatable(reading) {
     return undefined;
 }
 /** The path beside `configFile` its written configuration takes, which no file has. */
-function writtenPath(host, configFile) {
+export function writtenPath(host, configFile) {
     const stem = configFile.replace(/\.json$/u, "");
     for (let counter = 0;; counter += 1) {
         const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "6.1.0",
+  "version": "7.0.0-dev.1",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "6.1.0",
+  "version": "7.0.0-dev.1",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",

package/src/analysis.ts

@@ -84,7 +84,7 @@ import {
   type Matrix,
   type SweepResult,
 } from "./matrix.ts";
-import { joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
+import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
 import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
@@ -102,6 +102,7 @@ import { roots, unmatchedEverywhere, type RootKind, type Roots } from "./roots.t
 import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
 import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
+import { joinedTestFiles, withJoinedTests } from "./test-joins.ts";
 import { supportReferences, testSupportFiles } from "./test-support.ts";
 import { diagnosticsOf, ownedAs, runSession, type Engine, type ProjectView } from "./session.ts";
 import { accessorsOf, storesOf } from "./stores.ts";
@@ -308,6 +309,9 @@ function readProjects<Answer>(
     testFiles: config.ts.testFiles,
     parse: (fileName: string, text: string) => engine.parseSourceFile(fileName, text),
     publishedAPI: config.targetKind === "library",
+    publishedMembers: new Set(
+      (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
+    ),
   };
   const notBuilt: NotBuilt[] = [...discovered.notBuilt];
   const dropped = (configFile: string, error: string): void => {
@@ -332,6 +336,10 @@ function readProjects<Answer>(
       unbuildable.push(...met);
     }
   };
+  const testPatterns = config.ts.testFiles.map(globExpression);
+  const joins = discovered.derived
+    ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
+    : new Map<string, readonly string[]>();
   const session = runSession(
     engine,
     [...discovered.configFiles, ...consumerOf.keys()],
@@ -460,14 +468,15 @@ function readProjects<Answer>(
       return stage(project, { configuration, read });
     },
     discovered.derived ? "record" : "refuse",
-    workspace?.programs,
+    joins.size === 0
+      ? workspace?.programs
+      : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins),
     () => {
-      const patterns = config.ts.testFiles.map(globExpression);
       outsideTests = testFilesAt(
         host,
         targetRoot,
         sourcePaths(host, targetRoot).filter(
-          (path) => !heldFiles.has(path) && patterns.some((pattern) => pattern.test(path)),
+          (path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path)),
         ),
         options.parse,
       );
@@ -1082,27 +1091,44 @@ function readEmitterRun(
 }
 
 /**
- * The workspace members whose manifest the run reads whole enough to judge its
- * dependencies: a built project holds a file below the member's directory, and no derived
- * configuration at or below it was dropped. A file no built project holds may import any
- * dependency the member declares.
+ * The workspace members whose dependencies the run judges: `read` holds those a built
+ * project holds a file below, `unbuilt` the others whose own directory, the nearest
+ * manifest's above the configuration, holds a configuration the run could not build. A
+ * member no configuration holds a file of is in neither.
  */
-function membersWhollyRead(
+function judgedMembers(
   host: Host,
   targetRoot: string,
   read: ReadRun<EmitterExtra>,
-): readonly string[] {
+): { readonly read: readonly string[]; readonly unbuilt: readonly string[] } {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const held = new Set(read.matrix.union.symbols.map((symbol) => symbol.position.path));
-  const dropped = read.notBuilt.map((one) => relativePath(root, one.configFile) ?? "");
-  return read.memberDirs.filter((dir) => {
+  const owners = new Set(
+    read.notBuilt.map((one) => nearestManifestDir(host, root, one.configFile)),
+  );
+  const judged = { read: [] as string[], unbuilt: [] as string[] };
+  for (const dir of read.memberDirs) {
     const below = relativePath(root, dir);
     if (below === undefined) {
-      return false;
+      continue;
     }
-    const inside = (path: string): boolean => path.startsWith(`${below}/`);
-    return [...held].some(inside) && !dropped.some(inside);
-  });
+    if ([...held].some((path) => path.startsWith(`${below}/`))) {
+      judged.read.push(dir);
+    } else if (owners.has(dir)) {
+      judged.unbuilt.push(dir);
+    }
+  }
+  return judged;
+}
+
+/** The directory of the nearest `package.json` at or above a file, inside `root`, else `root`. */
+function nearestManifestDir(host: Host, root: string, file: string): string {
+  for (let dir = dirnamePath(file); relativePath(root, dir) !== undefined; dir = dirnamePath(dir)) {
+    if (host.kindOf(joinPath(dir, "package.json")) === "file") {
+      return dir;
+    }
+  }
+  return root;
 }
 
 /**
@@ -1120,6 +1146,7 @@ function emitterInputOver(
   const targetRoot = scope.target.path;
   const swept = sweptOf(read, input);
   const { projects } = read;
+  const members = judgedMembers(host, targetRoot, read);
   return {
     config,
     swept,
@@ -1137,7 +1164,8 @@ function emitterInputOver(
       targetRoot,
       [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)],
       swept.sweep.candidates.map((candidate) => candidate.id),
-      membersWhollyRead(host, targetRoot, read),
+      members.read,
+      members.unbuilt,
     ),
     implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
     files: {

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "4.1.0",
+    corpusVersion: "5.0.0",
     result: "pass",
-    digest: "sha256:167f770cdff2776fa7ab28b7ff6121c4d7bdb01d83c5ba0057d9303281614008",
+    digest: "sha256:26c486907df44fb8eaf3f749f60a6010ac94e7cfeeda70c4aa406445193ab80a",
   },
   gaps: [],
 } as const;

package/src/contextual-uses.ts

@@ -63,8 +63,13 @@ export interface ContextualUses {
   readonly lookups: number;
 }
 
-/** The name one literal property is written under, where the name is literal text. */
-function propertyName(property: Node): { node: Node; text: string } | undefined {
+/**
+ * The name one literal property is written under: its literal text, or the computed name
+ * node whose key the checker names, a unique symbol among them.
+ */
+function propertyName(
+  property: Node,
+): { node: Node; text: string } | { node: Node; text: undefined } | undefined {
   if (
     !isPropertyAssignment(property) &&
     !isShorthandPropertyAssignment(property) &&
@@ -83,6 +88,7 @@ function propertyName(property: Node): { node: Node; text: string } | undefined
     if (isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key)) {
       return { node: name, text: key.text };
     }
+    return { node: name, text: undefined };
   }
   return undefined;
 }
@@ -183,6 +189,31 @@ export function contextualUses<Brand>(
     literals.map((one) => one.literal),
     cap,
   );
+  // A computed name that is not literal text names the property the literal declares
+  // under the checker's own key, which is how a type declares a member a unique symbol
+  // keys: asked once, for the literals that have a contextual type.
+  const computed = literals.flatMap(({ literal }, index) =>
+    contexts[index] === undefined || !isAnswered(contexts[index])
+      ? []
+      : literal.properties.flatMap((property) => {
+          const name = propertyName(property);
+          return name !== undefined && name.text === undefined ? [name.node] : [];
+        }),
+  );
+  batches += batchesOf(computed.length);
+  const keys = new Map<Node, string>();
+  (computed.length === 0
+    ? []
+    : project.symbolsAt(
+        computed.map((node) => project.handle(node)),
+        cap,
+      )
+  ).forEach((symbol, index) => {
+    const node = computed[index];
+    if (node !== undefined && symbol !== undefined && isAnswered(symbol)) {
+      keys.set(node, symbol.name);
+    }
+  });
   literals.forEach(({ literal, from }, index) => {
     const context = contexts[index];
     if (context === undefined || !isAnswered(context)) {
@@ -191,10 +222,11 @@ export function contextualUses<Brand>(
     const tablesOf = partsOf(context).map(membersOf);
     for (const property of literal.properties) {
       const name = propertyName(property);
-      if (name === undefined) {
+      const text = name?.text ?? (name === undefined ? undefined : keys.get(name.node));
+      if (name === undefined || text === undefined) {
         continue;
       }
-      const ids = [...new Set(tablesOf.flatMap((table) => table.get(name.text)?.ids ?? []))];
+      const ids = [...new Set(tablesOf.flatMap((table) => table.get(text)?.ids ?? []))];
       if (ids.length > 0) {
         writes.push({ at: name.node, from, ids });
       }

package/src/convention-rows.ts

@@ -45,6 +45,14 @@ export interface HelperReading extends MoveReading {
   readonly package: string;
 }
 
+/** One member of a configuration file whose strings name the packages its tool loads. */
+export interface PackageKey {
+  /** The member's name, matched at any depth of the objects the row reads. */
+  readonly key: string;
+  /** Globs naming the configuration files, matched in the manifest's directory alone. */
+  readonly files: readonly string[];
+}
+
 /** One directory a row's globs name that a configuration property moves. */
 export interface DirectoryMove {
   /** The placeholder the row's globs and later moves write as `<id>`. */
@@ -83,6 +91,11 @@ export interface ConventionRow {
    * string there names no file the tool runs or loads.
    */
   readonly selections?: readonly MoveReading[];
+  /**
+   * The members whose strings name a package the tool loads: the package itself, a
+   * subpath of it, or the package followed by `:` and a name.
+   */
+  readonly packageKeys?: readonly PackageKey[];
   /** The members of a `package.json` the tool reads its configuration from. */
   readonly manifestKeys?: readonly string[];
   /** The settings that make the tool's output import a runtime helper package. */
@@ -131,8 +144,40 @@ const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
 const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
 
+/** The entry files of an Angular CLI project, at the workspace root or below `projects`. */
+const ANGULAR_ENTRIES = [
+  "src/{main,main.server,server,polyfills,test}.ts",
+  "server.ts",
+  "projects/*/src/{main,main.server,server,polyfills,test,public-api}.ts",
+  "projects/*/server.ts",
+];
+
+/** The `angular.json` members whose strings name the packages a build loads. */
+const ANGULAR_PACKAGE_KEYS: readonly PackageKey[] = [
+  "builder",
+  "polyfills",
+  "styles",
+  "scripts",
+].map((key) => ({ key, files: ["angular.json"] }));
+
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS: readonly ConventionRow[] = [
+  {
+    name: "angular",
+    package: "@angular/build",
+    range: ">=17.0.0 <22.0.0",
+    entries: ANGULAR_ENTRIES,
+    moves: [],
+    packageKeys: ANGULAR_PACKAGE_KEYS,
+  },
+  {
+    name: "angular-devkit",
+    package: "@angular-devkit/build-angular",
+    range: ">=12.0.0 <22.0.0",
+    entries: ANGULAR_ENTRIES,
+    moves: [],
+    packageKeys: ANGULAR_PACKAGE_KEYS,
+  },
   {
     name: "astro",
     package: "astro",
@@ -564,6 +609,18 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "vitepress",
+    package: "vitepress",
+    range: ">=1.0.0 <2.0.0-0 || >=2.0.0-alpha.0 <3.0.0",
+    entries: [
+      `.vitepress/config.${ANY_MODULE}`,
+      `.vitepress/theme/index.${ANY_MODULE}`,
+      `**/*.data.${ANY_MODULE}`,
+      "**/*.vue",
+    ],
+    moves: [],
+  },
   {
     name: "vitest",
     package: "vitest",