@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/dist/src/analysis.js

@@ -23,7 +23,7 @@ import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhi
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
 import { globExpression } from "./glob.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
-import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js";
+import { unmatchedRootFindings } from "./findings/self-check.js";
 import { frameworkLifecycle } from "./framework-lifecycle.js";
 import { implementations, mergeImplementations } from "./implementations.js";
 import { injectionContainer } from "./injection-container.js";
@@ -32,7 +32,7 @@ import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { SetupError, setupLine } from "./setup-failure.js";
 import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.js";
@@ -41,6 +41,7 @@ import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
+import { joinedTestFiles, withJoinedTests } from "./test-joins.js";
 import { supportReferences, testSupportFiles } from "./test-support.js";
 import { diagnosticsOf, ownedAs, runSession } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
@@ -119,6 +120,7 @@ function readProjects(engine, host, scope, config, stage) {
         testFiles: config.ts.testFiles,
         parse: (fileName, text) => engine.parseSourceFile(fileName, text),
         publishedAPI: config.targetKind === "library",
+        publishedMembers: new Set((workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir)),
     };
     const notBuilt = [...discovered.notBuilt];
     const dropped = (configFile, error) => {
@@ -144,6 +146,10 @@ function readProjects(engine, host, scope, config, stage) {
             unbuildable.push(...met);
         }
     };
+    const testPatterns = config.ts.testFiles.map(globExpression);
+    const joins = discovered.derived
+        ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
+        : new Map();
     const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (opened) => {
         const consumer = consumerOf.get(opened.configFile);
         const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
@@ -237,15 +243,17 @@ function readProjects(engine, host, scope, config, stage) {
                     .filter((file) => referenceOnly(file.fileName))
                     .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
                 generated: generatedFilesOf(own, generatedFiles(conventions, own)),
+                testFileNames: conventions.testFiles,
             };
         };
         for (const file of project.ownSourceFiles()) {
             heldFiles.add(relativePath(absoluteRoot, file.fileName) ?? file.fileName);
         }
         return stage(project, { configuration, read });
-    }, discovered.derived ? "record" : "refuse", workspace?.programs, () => {
-        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))), options.parse);
+    }, discovered.derived ? "record" : "refuse", joins.size === 0
+        ? workspace?.programs
+        : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins), () => {
+        outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path))), options.parse);
     });
     for (const configFile of session.unopened) {
         if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
@@ -339,7 +347,7 @@ export function runRoots(engine, host, scope, config, provenance) {
     };
 }
 /** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-const DETECTORS = new Map([
+export const DETECTORS = new Map([
     ["interface-satisfaction", interfaceSatisfaction],
     ["enum-group", enumGroup],
     ["generated-file", generatedFile],
@@ -367,6 +375,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const projectRead = opened.read();
         const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
+            testFileNames: projectRead.testFileNames,
         });
         const evidence = evidenceRecords({
             project,
@@ -412,7 +421,6 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const { projectRead } = one;
         const satisfied = settled[index];
         const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
-            disabled,
             mode,
             testFiles: new Set([...one.testFiles, ...support]),
         });
@@ -616,7 +624,7 @@ export function runSweep(engine, host, scope, config, input, detectors = DETECTO
     return sweptOf(readRun(engine, host, scope, config, input.mode, detectors, () => undefined), input);
 }
 /** Reads a run's projects with every per-project fact an emitter reads. */
-function readEmitterRun(engine, host, scope, config, mode, detectors) {
+export function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const targetRoot = scope.target.path;
     const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references) => ({
         deprecation: deprecatedDeclarations(project, read.held),
@@ -638,32 +646,48 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
         : { ...run, unansweredHeld: [...new Set([...run.unansweredHeld, ...unread])] };
 }
 /**
- * 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(host, targetRoot, read) {
+function judgedMembers(host, targetRoot, read) {
     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: [], unbuilt: [] };
+    for (const dir of read.memberDirs) {
         const below = relativePath(root, dir);
         if (below === undefined) {
-            return false;
+            continue;
         }
-        const inside = (path) => 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, root, file) {
+    for (let dir = dirnamePath(file); relativePath(root, dir) !== undefined; dir = dirnamePath(dir)) {
+        if (host.kindOf(joinPath(dir, "package.json")) === "file") {
+            return dir;
+        }
+    }
+    return root;
 }
 /**
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
  * each kind family reads, every per-project one read in the same session as the sweep.
  */
-function emitterInputOver(host, scope, config, read, input, selfCheck) {
+export function emitterInputOver(host, scope, config, read, input, selfCheck) {
     const targetRoot = scope.target.path;
     const swept = sweptOf(read, input);
     const { projects } = read;
+    const members = judgedMembers(host, targetRoot, read);
     return {
         config,
         swept,
@@ -672,7 +696,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
             references: one.configured.references,
             accessors: one.extra.accessors,
         })), swept.exempt, input.mode),
-        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), membersWhollyRead(host, targetRoot, read)),
+        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), members.read, members.unbuilt),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
             tree: sourceTree(host, targetRoot),
@@ -691,17 +715,6 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
         intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
     };
 }
-/**
- * What every emitter reads of the run the scope and the configuration describe, swept
- * under the caller's marks: the run's sweep, the facts beside it each kind family reads,
- * and the sides of the target's declared cross-language edges that name a symbol of this
- * language. The run reads no suppression document, so the self-check family has nothing
- * to report.
- */
-export function runEmitterInput(engine, host, scope, config, input, detectors = DETECTORS) {
-    const read = readEmitterRun(engine, host, scope, config, input.mode, detectors);
-    return emitterInputOver(host, scope, config, read, input, NO_SELF_CHECK);
-}
 /**
  * Reads the run the scope and the configuration describe for its findings. The inline
  * directives, the ignore file's entries and the baseline's rows are bound before any

package/dist/src/component-layer.js

@@ -7,7 +7,7 @@
  */
 import { dirnamePath, joinPath } from "./paths.js";
 /** The name the mapper's manifest declares and every configuration's entry names. */
-export const MAPPER_PACKAGE = "deadset-ts-component-files";
+const MAPPER_PACKAGE = "deadset-ts-component-files";
 /** The manifest of the mapper's package, which runs `command`. */
 export function mapperManifest(command) {
     return `${JSON.stringify({

package/dist/src/configuration-files.js

@@ -50,10 +50,16 @@ export const RESOLVED_EXTENSIONS = [
     ".mjs",
     ".cjs",
 ];
+/** The directory a package manager installs packages into, whose files are no project's own. */
+const MODULES_DIR = "node_modules";
 /** The file's name, the last segment of its path. */
 function basename(path) {
     return path.slice(path.lastIndexOf("/") + 1);
 }
+/** Whether one path is the project's own: below the target root and in no `node_modules`. */
+function isProjectPath(root, path) {
+    return relativePath(root, path)?.split("/").includes(MODULES_DIR) === false;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -65,6 +71,160 @@ export function configurationModuleForm(name) {
 export function isConfigurationDocumentName(name) {
     return DOCUMENT_NAME.test(name);
 }
+/** The flags a tool's command line names its configuration file with. */
+const CONFIG_FLAGS = new Set(["--config", "-c"]);
+/** The extensions of a module a configuration flag may name. */
+const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+/** The characters that end a word outside quotes and separate nothing: blanks. */
+const BLANK = /[ \t\r\f\v]/u;
+/** The characters that end a word outside quotes and begin an operator: newline included. */
+const OPERATOR = /[\n;&|()<>]/u;
+/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
+const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
+/**
+ * The words of one command line, as POSIX token recognition reads quotes, backslashes,
+ * line continuations, comments and operators. A word an expansion may change (an unquoted
+ * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
+ * is computed, and so is the rest of a line whose quote is never closed. A computed word
+ * and each operator are undefined, so a flag's file is never read across them.
+ */
+function shellWords(command) {
+    const words = [];
+    let word;
+    let computed = false;
+    const end = () => {
+        if (word !== undefined) {
+            words.push(computed ? undefined : word);
+        }
+        word = undefined;
+        computed = false;
+    };
+    for (let at = 0; at < command.length; at += 1) {
+        const char = command.charAt(at);
+        if (char === "\\" && command.charAt(at + 1) === "\n") {
+            at += 1;
+        }
+        else if (BLANK.test(char)) {
+            end();
+        }
+        else if (OPERATOR.test(char)) {
+            end();
+            words.push(undefined);
+        }
+        else if (char === "#" && word === undefined) {
+            const newline = command.indexOf("\n", at);
+            at = newline < 0 ? command.length : newline - 1;
+        }
+        else if (char === "\\") {
+            at += 1;
+            word = (word ?? "") + command.charAt(at);
+        }
+        else if (char === "'" || char === '"') {
+            const close = closingQuote(command, at);
+            if (close < 0) {
+                word ??= "";
+                computed = true;
+                break;
+            }
+            const quoted = char === "'"
+                ? { text: command.slice(at + 1, close), computed: false }
+                : doubleQuoted(command.slice(at + 1, close));
+            word = (word ?? "") + quoted.text;
+            computed ||= quoted.computed;
+            at = close;
+        }
+        else {
+            computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
+            word = (word ?? "") + char;
+        }
+    }
+    end();
+    return words;
+}
+/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
+function doubleQuoted(inner) {
+    let text = "";
+    let computed = false;
+    for (let at = 0; at < inner.length; at += 1) {
+        const char = inner.charAt(at);
+        const next = inner.charAt(at + 1);
+        if (char === "\\" && next === "\n") {
+            at += 1;
+        }
+        else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
+            text += next;
+            at += 1;
+        }
+        else {
+            computed ||= char === "$" || char === "`";
+            text += char;
+        }
+    }
+    return { text, computed };
+}
+/** The index of the quote that closes the one at `open`, or -1 where none does. */
+function closingQuote(command, open) {
+    const quote = command.charAt(open);
+    for (let at = open + 1; at < command.length; at += 1) {
+        const char = command.charAt(at);
+        if (char === quote) {
+            return at;
+        }
+        if (quote === '"' && char === "\\") {
+            at += 1;
+        }
+    }
+    return -1;
+}
+/**
+ * The files the scripts of the manifest in one directory name after a configuration flag,
+ * `--config <file>`, `-c <file>` or `--config=<file>`, each a JSON file or a module below
+ * the target root and in no `node_modules`.
+ */
+function scriptConfigurations(host, root, dir) {
+    let scripts;
+    try {
+        const manifest = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
+        scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
+    }
+    catch {
+        return [];
+    }
+    if (!isRecord(scripts)) {
+        return [];
+    }
+    const found = [];
+    for (const command of Object.values(scripts)) {
+        if (typeof command !== "string") {
+            continue;
+        }
+        const words = shellWords(command);
+        words.forEach((word, at) => {
+            const named = word !== undefined && CONFIG_FLAGS.has(word)
+                ? words[at + 1]
+                : word === undefined
+                    ? undefined
+                    : /^--config=(.+)$/su.exec(word)?.[1];
+            const path = named === undefined ? undefined : resolvePath(dir, named);
+            if (path !== undefined &&
+                [".json", ...MODULE_EXTENSIONS].some((extension) => path.endsWith(extension)) &&
+                isProjectPath(root, path) &&
+                host.kindOf(path) === "file") {
+                found.push(path);
+            }
+        });
+    }
+    return found;
+}
+/** The decoded value of one JSON file, or undefined where it cannot be read or parsed. */
+function readDocument(host, path) {
+    try {
+        return JSON.parse(host.readFile(path));
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Every string value one decoded JSON value holds at any depth. */
 export function documentStrings(value) {
     if (typeof value === "string") {
@@ -116,7 +276,8 @@ export function configurationFiles(host, targetRoot, files, parse) {
             dirs.add(dir);
         }
     }
-    const documents = [];
+    const pending = [];
+    const named = [];
     for (const dir of [...dirs].sort()) {
         if (!holdsManifest(dir)) {
             continue;
@@ -130,24 +291,57 @@ export function configurationFiles(host, targetRoot, files, parse) {
                 .sort();
         }
         catch {
-            continue;
+            names = [];
         }
-        for (const name of names) {
-            const path = joinPath(dir, name);
-            let value;
-            try {
-                value = JSON.parse(host.readFile(path));
+        pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
+        for (const path of scriptConfigurations(host, root, dir)) {
+            const held = files.byName.get(path);
+            if (path.endsWith(".json")) {
+                pending.push({ path, manifestDir: dir });
             }
-            catch {
+            else if (held !== undefined) {
+                modules.push({ file: held, form: "a script's configuration flag" });
+            }
+            else {
+                named.push({ path, manifestDir: dir });
+            }
+        }
+    }
+    // A document reached from two manifests is read against each, so a chain is keyed by both.
+    const documents = new Map();
+    const unreadable = new Set();
+    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+        let document = documents.get(next.path);
+        if (unreadable.has(next.path) || document?.manifestDirs.includes(next.manifestDir) === true) {
+            continue;
+        }
+        if (document === undefined) {
+            const value = readDocument(host, next.path);
+            if (value === undefined) {
+                unreadable.add(next.path);
                 continue;
             }
-            documents.push({ path, strings: documentStrings(value) });
+            document = { path: next.path, manifestDirs: [], strings: documentStrings(value) };
+            documents.set(next.path, document);
+        }
+        document.manifestDirs.push(next.manifestDir);
+        for (const text of document.strings) {
+            const path = RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix))
+                ? resolvePath(dirnamePath(next.path), text)
+                : undefined;
+            if (path?.endsWith(".json") === true &&
+                isProjectPath(root, path) &&
+                host.kindOf(path) === "file") {
+                pending.push({ path, manifestDir: next.manifestDir });
+            }
         }
     }
     return {
         modules,
-        documents,
-        outside: parse === undefined ? [] : outsideModules(host, [...dirs], files, holdsManifest, parse),
+        documents: [...documents.values()],
+        outside: parse === undefined
+            ? []
+            : outsideModules(host, [...dirs], files, holdsManifest, parse, named),
     };
 }
 /** The relative specifiers one file's imports and re-exports name. */
@@ -195,8 +389,8 @@ export function resolveRelativeSpecifier(host, dir, specifier) {
  * does not hold, and the files they import by a relative specifier, until no further
  * file joins. A file that cannot be read is skipped.
  */
-function outsideModules(host, dirs, files, holdsManifest, parse) {
-    const pending = [];
+function outsideModules(host, dirs, files, holdsManifest, parse, named) {
+    const pending = [...named];
     for (const dir of [...dirs].sort()) {
         if (!holdsManifest(dir)) {
             continue;
@@ -214,30 +408,36 @@ function outsideModules(host, dirs, files, holdsManifest, parse) {
         }
         pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
     }
-    const found = [];
-    const seen = new Set();
+    const found = new Map();
+    const unreadable = new Set();
     for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-        if (seen.has(next.path) || files.byName.has(next.path)) {
+        let outside = found.get(next.path);
+        if (unreadable.has(next.path) ||
+            files.byName.has(next.path) ||
+            outside?.manifestDirs.includes(next.manifestDir) === true) {
             continue;
         }
-        seen.add(next.path);
-        let text;
-        try {
-            text = host.readFile(next.path);
-        }
-        catch {
-            continue;
+        if (outside === undefined) {
+            let text;
+            try {
+                text = host.readFile(next.path);
+            }
+            catch {
+                unreadable.add(next.path);
+                continue;
+            }
+            outside = { file: parse(next.path, text), manifestDirs: [] };
+            found.set(next.path, outside);
         }
-        const file = parse(next.path, text);
-        found.push({ file, manifestDir: next.manifestDir });
-        for (const specifier of relativeSpecifiers(file)) {
+        outside.manifestDirs.push(next.manifestDir);
+        for (const specifier of relativeSpecifiers(outside.file)) {
             const reached = resolveRelativeSpecifier(host, dirnamePath(next.path), specifier);
             if (reached !== undefined) {
                 pending.push({ path: reached, manifestDir: next.manifestDir });
             }
         }
     }
-    return found;
+    return [...found.values()];
 }
 /** Every dependency the manifest in one directory declares, or none where it holds none to read. */
 export function declaredIn(host, dir) {

package/dist/src/conformance-record.js

@@ -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: [],
 };