@cplieger/deadset-ts 5.0.0 → 5.1.1

package/README.md

@@ -90,7 +90,7 @@ A TypeScript caller that imports the source sets `allowImportingTsExtensions`, b
 
 ## Related projects
 
-deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset-spec), which fixes the issue codes, the report schema and the exit codes. It passes every fixture of the Contract's conformance corpus except one reflective-lookup fixture, the gap [`conformance.json`](conformance.json) declares.
+deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset-spec), which fixes the issue codes, the report schema and the exit codes. It passes every fixture of the Contract's conformance corpus.
 
 - [deadset-go](https://github.com/cplieger/deadset-go) is the same analysis for Go modules.
 - [deadset](https://github.com/cplieger/deadset) runs both analyzers as one command and merges their reports, resolving the edges between Go and TypeScript code.

package/dist/src/analysis.js

@@ -14,11 +14,14 @@ import { decorator } from "./decorator.js";
 import { dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
-import { conventionFailuresFor, readConventions, } from "./conventions.js";
+import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
-import { computeExemptions, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
-import { heldByInclusion, sourceTree } from "./file-facts.js";
+import { generatedFile } from "./generated-file.js";
+import { sourceFilesOf } from "./source-files.js";
+import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
+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 { frameworkLifecycle } from "./framework-lifecycle.js";
@@ -27,9 +30,9 @@ import { injectionContainer } from "./injection-container.js";
 import { interfaceSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
-import { readManifest } from "./manifest.js";
+import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { joinPath, relativePath, resolvePath } from "./paths.js";
+import { 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";
@@ -37,6 +40,7 @@ import { reflectiveLookup } from "./reflective-lookup.js";
 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 { supportReferences, testSupportFiles } from "./test-support.js";
 import { diagnosticsOf, ownedAs, runSession } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
@@ -105,11 +109,15 @@ function readProjects(engine, host, scope, config, stage) {
     const options = {
         host,
         manifest: workspace?.manifest ?? readManifest(host, targetRoot),
-        workspaceEntries: workspace?.entries,
+        otherPackages: [
+            ...(workspace?.entries ?? []),
+            ...packageEntries(host, normalizePath(absoluteRoot), discovered.configFiles, new Set(workspace?.memberDirs ?? [])),
+        ],
         patterns: config.rootPatterns,
         entryFiles: config.ts.entryFiles,
         conventions,
         testFiles: config.ts.testFiles,
+        parse: (fileName, text) => engine.parseSourceFile(fileName, text),
         publishedAPI: config.targetKind === "library",
     };
     const notBuilt = [...discovered.notBuilt];
@@ -124,6 +132,8 @@ function readProjects(engine, host, scope, config, stage) {
     const unbuildable = [];
     const setupDropped = [];
     const consumed = new Map();
+    const heldFiles = new Set();
+    let outsideTests = [];
     const setupMet = (configFile, met) => {
         const [first] = met;
         if (first !== undefined && isGuess(discovered, configFile)) {
@@ -225,10 +235,17 @@ function readProjects(engine, host, scope, config, stage) {
                     .ownSourceFiles()
                     .filter((file) => referenceOnly(file.fileName))
                     .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
+                generated: generatedFiles(conventions, sourceFilesOf(project, targetRoot)),
             };
         };
+        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);
+    }, 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);
+    });
     for (const configFile of session.unopened) {
         if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
             throw new DiscoveryError(`${configFile} opened no project`, []);
@@ -259,6 +276,7 @@ function readProjects(engine, host, scope, config, stage) {
         unanswered: session.unanswered,
         componentsUnread: workspace?.componentsUnread ?? [],
         conventionsApplied: conventions.applied,
+        outsideTests,
     };
 }
 /**
@@ -321,6 +339,7 @@ export function runRoots(engine, host, scope, config, provenance) {
 const DETECTORS = new Map([
     ["interface-satisfaction", interfaceSatisfaction],
     ["enum-group", enumGroup],
+    ["generated-file", generatedFile],
     ["template-field", templateField],
     ["reflective-lookup", reflectiveLookup],
     ["decorator", decorator],
@@ -346,52 +365,88 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
         });
-        const support = testSupportFiles(projectRead.held.symbols, resolved.references, projectRead.rooted.liveUnderReachability, resolved.testFilePaths);
-        const made = supportReferences(resolved.references, support);
+        const evidence = evidenceRecords({
+            project,
+            held: projectRead.held,
+            targetRoot,
+            templates,
+            ts: config.ts,
+            consumers,
+            ...(config.analysis.generatedFiles === "include"
+                ? {}
+                : { generated: projectRead.generated }),
+        }, detectors, disabled);
+        const components = project.ownSourceFiles().filter(isComponentFile);
+        const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
+        return {
+            projectRead,
+            references: resolved.references,
+            testFiles: resolved.testFilePaths,
+            evidence,
+            componentFiles: components.map(pathOf),
+            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
+                path: pathOf(file),
+                line: lineOf(file.originalText, warning.offset),
+                reason: warning.reason,
+            }))),
+            extra: extra(project, projectRead, resolved.references),
+        };
+    });
+    const outsidePaths = read.outsideTests.map((one) => one.path);
+    const withOutside = read.answers.map((one) => ({
+        ...one,
+        references: [
+            ...one.references,
+            ...outsideTestReferences(read.outsideTests, one.projectRead.held, targetRoot),
+        ],
+        testFiles: [...one.testFiles, ...outsidePaths],
+    }));
+    // Test-support code is code only test code imports in any configuration of the run: a
+    // configuration that holds no test file says nothing about what the tests import.
+    const support = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles));
+    const answers = withOutside.map((one) => {
+        const { projectRead } = one;
+        const detected = heldRecords(one.evidence, {
+            disabled,
+            mode,
+            testFiles: new Set([...one.testFiles, ...support]),
+        });
+        const exempt = detected.records;
+        const made = supportReferences(one.references, support);
+        const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
+        const supportFiles = [...support].filter((path) => held.has(path)).sort();
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
-            references: made,
+            references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
             roots: projectRead.rooted.liveUnderReachability,
-            testFiles: resolved.testFilePaths,
-            ...(support.size === 0 ? {} : { supportFiles: [...support].sort() }),
+            testFiles: one.testFiles,
+            ...(supportFiles.length === 0 ? {} : { supportFiles }),
             ...(projectRead.referenceOnly.length === 0
                 ? {}
                 : { referenceOnly: projectRead.referenceOnly }),
         };
-        const exempt = computeExemptions({ project, held: projectRead.held, targetRoot, templates, ts: config.ts, consumers }, detectors, {
-            disabled,
-            mode,
-            testFiles: new Set([...resolved.testFilePaths, ...support]),
-        });
-        const unanswered = [
-            ...projectRead.held.unanswered,
-            ...projectRead.rooted.unanswered,
-            ...made
-                .filter((reference) => reference.resolution === "by-name")
-                .map((reference) => reference.to),
-            ...exempt.filter(isUnansweredRecord).map((record) => record.id),
-        ];
-        const components = project.ownSourceFiles().filter(isComponentFile);
-        const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
         return {
             configFile: projectRead.configFile,
             configured,
             exempt,
-            unanswered,
+            unanswered: [
+                ...projectRead.held.unanswered,
+                ...projectRead.rooted.unanswered,
+                ...made
+                    .filter((reference) => reference.resolution === "by-name")
+                    .map((reference) => reference.to),
+                ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+            ],
             typeErrorSkips: projectRead.typeErrorSkips,
             skipped: projectRead.skipped,
-            componentFiles: components.map(pathOf),
-            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
-                path: pathOf(file),
-                line: lineOf(file.originalText, warning.offset),
-                reason: warning.reason,
-            }))),
-            extra: extra(project, projectRead, made),
+            componentFiles: one.componentFiles,
+            componentWarnings: one.componentWarnings,
+            extra: one.extra,
         };
     });
     const consumed = read.consumers.references;
-    const projects = read.answers.map((one) => consumed.length === 0
+    const projects = answers.map((one) => consumed.length === 0
         ? one
         : {
             ...one,
@@ -405,7 +460,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         exempt: exemptionsOf(projects.flatMap((one) => one.exempt)),
         unansweredHeld: [
             ...new Set([
-                ...read.answers.flatMap((one) => one.unanswered),
+                ...answers.flatMap((one) => one.unanswered),
                 ...consumed.filter((one) => one.resolution === "by-name").map((one) => one.to),
             ]),
         ],
@@ -440,6 +495,55 @@ function holdingSweep(read, input) {
         live = next;
     }
 }
+/**
+ * The test references exemption evidence written in a test file makes: each is a read of
+ * the declaration it would retain, made by the test file at the evidence's site.
+ */
+function evidenceReferences(symbols, inTestFiles) {
+    if (inTestFiles.length === 0) {
+        return [];
+    }
+    const files = new Map(symbols
+        .filter((symbol) => symbol.kind === "file")
+        .map((symbol) => [symbol.position.path, symbol.id]));
+    return inTestFiles.flatMap((record) => {
+        const from = files.get(record.site.path);
+        return from === undefined
+            ? []
+            : [
+                {
+                    from,
+                    to: record.id,
+                    position: record.site,
+                    use: "read",
+                    resolution: "syntax",
+                    test: true,
+                },
+            ];
+    });
+}
+/**
+ * The declarations every reference the mode counts stores into, a loaded consumer's
+ * reference counting as a read: what the write-only kind would report but for a record.
+ */
+function writtenOnly(read, mode) {
+    const written = new Set();
+    const readSome = new Set();
+    for (const { configured } of read.projects) {
+        for (const reference of configured.references) {
+            if (mode.production && reference.test) {
+                continue;
+            }
+            if (reference.use === "write" && reference.consumer === undefined) {
+                written.add(reference.to);
+            }
+            else {
+                readSome.add(reference.to);
+            }
+        }
+    }
+    return new Set([...written].filter((id) => !readSome.has(id)));
+}
 /**
  * The sweep of a run read once, under one set of marks. Where a question went unanswered,
  * the run is swept once more without what that question could have kept live and without
@@ -483,7 +587,7 @@ function sweptOf(read, input) {
         matrix: read.matrix,
         sweep: result,
         exempt,
-        retained: retainedIn(read.matrix, swept),
+        retained: retainedIn(read.matrix, swept, writtenOnly(read, input.mode)),
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
         heldByUnanswered: [...held],
@@ -510,9 +614,10 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references) => ({
         deprecation: deprecatedDeclarations(project, read.held),
         accessors: accessorsOf(project, read.held),
-        needs: projectNeeds(project, read.held, host, targetRoot),
+        needs: projectNeeds(project, read.held, host, targetRoot, (fileName, text) => engine.parseSourceFile(fileName, text)),
         implementations: implementations(project, read.held),
         heldByInclusion: heldByInclusion(project, targetRoot),
+        generated: [...read.generated.keys()],
         rooted: read.rooted,
         directives: inlineDirectives(project, read.held, targetRoot).filter((directive) => !read.referenceOnly.includes(directive.site.path)),
         declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
@@ -546,6 +651,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
         files: {
             tree: sourceTree(host, targetRoot),
             heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
+            generated: new Set(projects.flatMap((one) => one.extra.generated)),
         },
         boundary: {
             consumers: {

package/dist/src/configuration-files.js

@@ -6,7 +6,7 @@
  * every string either holds as it likes, so each one that spells a declared dependency
  * uses it and each relative one that names a source file of the program roots the file.
  */
-import { isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { isExportDeclaration, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/unstable/ast";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 const MANIFEST = "package.json";
 /** A configuration module's name, each form with the spelling a root reports it by. */
@@ -29,8 +29,17 @@ const DEPENDENCY_MEMBERS = [
 ];
 /** The prefixes a string names a file with, relative to the file that writes it. */
 const RELATIVE_PREFIXES = ["./", "../"];
+/** The JavaScript extensions a relative specifier from a configuration file stands for TypeScript under. */
+const COUNTERPARTS = [
+    [".js", [".ts", ".tsx"]],
+    [".jsx", [".tsx", ".ts"]],
+    [".mjs", [".mts"]],
+    [".cjs", [".cts"]],
+];
+/** The extensions appended to a relative specifier from a configuration file, in order. */
+const APPENDED = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 /** The extensions the program's module resolution appends to a specifier written without one. */
-const RESOLVED_EXTENSIONS = [
+export const RESOLVED_EXTENSIONS = [
     ".ts",
     ".tsx",
     ".d.ts",
@@ -85,7 +94,7 @@ export function moduleStrings(file) {
  * in a directory that holds a manifest. A document that cannot be read or parsed as
  * JSON holds no string.
  */
-export function configurationFiles(host, targetRoot, files) {
+export function configurationFiles(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const manifests = new Map();
     const holdsManifest = (dir) => {
@@ -135,7 +144,102 @@ export function configurationFiles(host, targetRoot, files) {
             documents.push({ path, strings: documentStrings(value) });
         }
     }
-    return { modules, documents };
+    return {
+        modules,
+        documents,
+        outside: parse === undefined ? [] : outsideModules(host, [...dirs], files, holdsManifest, parse),
+    };
+}
+/** The relative specifiers one file's imports and re-exports name. */
+function relativeSpecifiers(file) {
+    return file.statements.flatMap((statement) => {
+        const specifier = isImportDeclaration(statement) || isExportDeclaration(statement)
+            ? statement.moduleSpecifier
+            : undefined;
+        return specifier !== undefined &&
+            isStringLiteral(specifier) &&
+            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
+            ? [specifier.text]
+            : [];
+    });
+}
+/**
+ * The module one relative specifier from a configuration file reaches: the path it names,
+ * that path with its JavaScript extension replaced by the TypeScript counterparts, that
+ * path with an extension appended, and a directory's `index` with one appended.
+ */
+function reachedBy(host, dir, specifier) {
+    const path = resolvePath(dir, specifier);
+    const isFile = (candidate) => host.kindOf(candidate) === "file";
+    // A data file such as `./package.json` is no module, so its strings use no dependency.
+    if (isFile(path) && APPENDED.some((extension) => path.endsWith(extension))) {
+        return path;
+    }
+    for (const [extension, counterparts] of COUNTERPARTS) {
+        if (path.endsWith(extension)) {
+            const stem = path.slice(0, -extension.length);
+            const found = counterparts.map((one) => stem + one).find(isFile);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+    }
+    const appended = APPENDED.map((extension) => path + extension).find(isFile);
+    if (appended !== undefined) {
+        return appended;
+    }
+    return host.kindOf(path) === "directory"
+        ? APPENDED.map((extension) => joinPath(path, `index${extension}`)).find(isFile)
+        : undefined;
+}
+/**
+ * The configuration modules of the directories that hold a manifest which the program
+ * 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 = [];
+    for (const dir of [...dirs].sort()) {
+        if (!holdsManifest(dir)) {
+            continue;
+        }
+        let names;
+        try {
+            names = host
+                .readDirectory(dir)
+                .filter((entry) => !entry.directory && configurationModuleForm(entry.name) !== undefined)
+                .map((entry) => entry.name)
+                .sort();
+        }
+        catch {
+            continue;
+        }
+        pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
+    }
+    const found = [];
+    const seen = new Set();
+    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+        if (seen.has(next.path) || files.byName.has(next.path)) {
+            continue;
+        }
+        seen.add(next.path);
+        let text;
+        try {
+            text = host.readFile(next.path);
+        }
+        catch {
+            continue;
+        }
+        const file = parse(next.path, text);
+        found.push({ file, manifestDir: next.manifestDir });
+        for (const specifier of relativeSpecifiers(file)) {
+            const reached = reachedBy(host, dirnamePath(next.path), specifier);
+            if (reached !== undefined) {
+                pending.push({ path: reached, manifestDir: next.manifestDir });
+            }
+        }
+    }
+    return found;
 }
 /** 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,15 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "2.1.1",
+        corpusVersion: "2.2.0",
         result: "pass",
-        digest: "sha256:e5e456bf3a706f1fa9f906ae71e10ea98a78da52d7d99a5ed59dca8a72bbe927",
+        digest: "sha256:ce7c9087ed7b2baf3de9fa2df436b500706f4f9e94fd9e0fed633054305f06a4",
     },
-    gaps: [
-        {
-            fixture: "private-member-unread",
-            capability: "reflective-lookup",
-            reason: "The reference pass resolves a string-literal element access to the member it names, so the member is live by that reference and the retained listing names no class for it.",
-        },
-    ],
+    gaps: [],
 };