@cplieger/deadset-ts 4.0.1 → 5.0.0

package/dist/src/session.js

@@ -1,5 +1,7 @@
 import { API, SymbolFlags } from "@typescript/native/unstable/sync";
+import { componentLayer, mapperManifest } from "./component-layer.js";
 import { DiscoveryError } from "./discover.js";
+import { joinPath } from "./paths.js";
 import { queriesOf, UnansweredLog, } from "./query.js";
 /**
  * Opens the compiler client the analysis reads through.
@@ -9,11 +11,55 @@ import { queriesOf, UnansweredLog, } from "./query.js";
  * second call has nothing left to do.
  */
 export function openEngine(options) {
-    const api = new API({ collectTiming: options.collectTiming });
+    const { components } = options;
+    let mapper;
+    if (components !== undefined && components.extensions.length > 0) {
+        const made = components.host.temporaryDirectory();
+        try {
+            components.host.writeDocument(joinPath(made.path, "package.json"), [
+                mapperManifest(components.host.componentMapperCommand()),
+            ]);
+        }
+        catch (error) {
+            made.remove();
+            throw error;
+        }
+        mapper = made;
+    }
+    const api = new API({
+        collectTiming: options.collectTiming,
+        ...(mapper === undefined ? {} : { runExternalCode: true }),
+    });
     let closed = false;
     return {
         parseConfigFile: (file) => api.parseConfigFile(file),
-        createSnapshot: (openProjects) => api.createSnapshot({ openProjects: [...openProjects] }),
+        parseConfigJson: (json, configFile) => api.parseJsonConfigFileContent(json, { configFileName: configFile }),
+        createSnapshot: (openProjects, createPrograms, configurations = new Map()) => api.createSnapshot({
+            openProjects: [...openProjects],
+            ...(createPrograms === undefined ? {} : { createPrograms: [...createPrograms] }),
+            ...(components === undefined
+                ? configurations.size === 0
+                    ? {}
+                    : { fileSystem: { kind: "layer", files: Object.fromEntries(configurations) } }
+                : {
+                    fileSystem: componentLayer(components.host, openProjects, mapper === undefined
+                        ? undefined
+                        : { extensions: components.extensions, packageDirectory: mapper.path }, configurations),
+                }),
+        }),
+        readsComponents: mapper !== undefined,
+        createModuleResolver: (options, entries) => api.createModuleResolver(options, {
+            moduleResolutions: { fallback: "resolve", entries: [...entries] },
+        }),
+        parseSourceFile: (fileName, text) => {
+            const retained = api.createSourceFile(fileName, text);
+            try {
+                return retained.sourceFile;
+            }
+            finally {
+                retained.dispose();
+            }
+        },
         batch: (questions) => api.batch(...questions),
         ask: (_accessor, _locations, question) => question(),
         getTimingInfo: () => api.getTimingInfo(),
@@ -22,10 +68,35 @@ export function openEngine(options) {
                 return;
             }
             closed = true;
-            api.close();
+            try {
+                api.close();
+            }
+            finally {
+                mapper?.remove();
+            }
         },
     };
 }
+/**
+ * The source files of one program that `own` admits, in the program's order, none of
+ * them one of the compiler's default libraries.
+ */
+function filesOwned(program, own) {
+    return (program
+        .getSourceFileNames()
+        // The metadata decides which files belong to the target, and it is read by
+        // name. Fetching each file first and filtering afterwards costs one round
+        // trip per library file the answer then discards, and a program holds far
+        // more library files than target files.
+        .filter((name) => {
+        const metadata = program.getSourceFileMetadata(name);
+        return (metadata !== undefined &&
+            !metadata.isDefaultLibrary &&
+            own(name, metadata.isFromExternalLibrary));
+    })
+        .map((name) => program.getSourceFile(name))
+        .filter((file) => file !== undefined));
+}
 function viewOf(project, configFile, engine, log) {
     const queries = queriesOf(project.checker, configFile, (questions) => engine.batch(questions), log, (accessor, locations, question) => engine.ask(accessor, locations, question));
     // The snapshot is never updated, so a project's own file set is the same answer
@@ -35,23 +106,13 @@ function viewOf(project, configFile, engine, log) {
     let ownFiles;
     let ownKeys;
     const ownSourceFiles = () => {
-        ownFiles ??= project.program
-            .getSourceFileNames()
-            // The metadata decides which files belong to the target, and it is read by
-            // name. Fetching each file first and filtering afterwards costs one round
-            // trip per library file the answer then discards, and a program holds far
-            // more library files than target files.
-            .filter((name) => {
-            const metadata = project.program.getSourceFileMetadata(name);
-            return (metadata !== undefined && !metadata.isDefaultLibrary && !metadata.isFromExternalLibrary);
-        })
-            .map((name) => project.program.getSourceFile(name))
-            .filter((file) => file !== undefined);
+        ownFiles ??= filesOwned(project.program, (_name, fromExternalLibrary) => !fromExternalLibrary);
         return ownFiles;
     };
     return {
         configFile,
         program: project.program,
+        rootFiles: project.parsedCommandLine.fileNames,
         queries,
         ownSourceFiles,
         ownPaths: () => {
@@ -101,6 +162,26 @@ export function narrowedTo(project, keep) {
         },
     };
 }
+/**
+ * The same project, its own source files the ones `own` admits among every file its
+ * program holds, given whether the compiler reached the file as a library's.
+ */
+export function ownedAs(project, own) {
+    let owned;
+    let keys;
+    const ownSourceFiles = () => {
+        owned ??= filesOwned(project.program, own);
+        return owned;
+    };
+    return {
+        ...project,
+        ownSourceFiles,
+        ownPaths: () => {
+            keys ??= new Set(ownSourceFiles().map((file) => file.path));
+            return keys;
+        },
+    };
+}
 /** The three diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf(project) {
     return {
@@ -119,28 +200,54 @@ export function diagnosticsOf(project) {
     };
 }
 /**
- * Runs `visit` over every project the compiler configurations name, inside one
- * snapshot of one client, in the order they are named, and answers in that order.
- *
- * The snapshot is opened once with every configuration, so each becomes a project
- * with its own program and checker; it is never updated, because the analysis
- * reads and the tree does not change under it. The order the snapshot lists its
- * projects in is the compiler's own, so each named configuration is looked up in it
- * instead. A configuration the snapshot opened no project for ends the run under
- * `"refuse"` and is named in the result under `"record"`. The snapshot is disposed once
- * the last project has been visited, and the client is released after it, whether the
- * visit completed or threw.
+ * The projects one snapshot holds for the configurations named, by configuration file. A
+ * project opened from a written configuration is the project of the configuration
+ * `written` maps it to.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse") {
+function projectsOf(snapshot, built, written) {
+    const opened = new Map();
+    for (const project of snapshot.getProjects()) {
+        if (project.configFileName !== undefined) {
+            opened.set(written.get(project.configFileName) ?? project.configFileName, project);
+        }
+    }
+    (snapshot.operation.createdPrograms ?? []).forEach((program, at) => {
+        const project = snapshot.getProject(program.id);
+        const configFile = built[at];
+        if (project !== undefined && configFile !== undefined) {
+            opened.set(configFile, project);
+        }
+    });
+    return opened;
+}
+/**
+ * Runs `visit` over every project the compiler configurations name, inside one never updated
+ * snapshot of one client, and answers in their order. A configuration `programs` describes is
+ * built as that program, or opened from the configuration it writes, instead of as a project.
+ * One the snapshot holds nothing for ends the run under `"refuse"` and is named in the result
+ * under `"record"`. The snapshot is disposed after the last visit and the client released
+ * after it, whether the visit completed or threw.
+ */
+export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map()) {
     try {
-        const snapshot = engine.createSnapshot(configFiles);
-        try {
-            const opened = new Map();
-            for (const project of snapshot.getProjects()) {
-                if (project.configFileName !== undefined) {
-                    opened.set(project.configFileName, project);
-                }
+        const built = [];
+        const params = [];
+        const written = new Map();
+        const texts = new Map();
+        for (const configFile of configFiles) {
+            const program = programs.get(configFile);
+            if (program?.kind === "program") {
+                built.push(configFile);
+                params.push(program.params);
+            }
+            else if (program?.kind === "configuration") {
+                written.set(program.file, configFile);
+                texts.set(program.file, program.text);
             }
+        }
+        const snapshot = engine.createSnapshot([...configFiles.filter((configFile) => !programs.has(configFile)), ...written.keys()], params.length === 0 ? undefined : params, texts);
+        try {
+            const opened = projectsOf(snapshot, built, written);
             const log = new UnansweredLog();
             const projects = [];
             const missing = [];

package/dist/src/setup-failure.js

@@ -0,0 +1,23 @@
+/**
+ * A setup failure: a file or a component the analysis needs and the project does not
+ * provide. Each one names what is missing and the fix, on one line of the error stream
+ * that starts with its class.
+ */
+/** The failure as the one line of the error stream that names it. */
+export function setupLine(failure) {
+    return `setup failure: ${failure.setupClass}: ${failure.detail}`;
+}
+/**
+ * A run that met a setup failure where none may be dropped: in a configuration the
+ * configuration document or the scope declares, in a declared consumer, or in every
+ * configuration discovery derived. It ends the run with the failure code and no finding
+ * list.
+ */
+export class SetupError extends Error {
+    failures;
+    constructor(failures) {
+        super(failures.map(setupLine).join("\n"));
+        this.name = "SetupError";
+        this.failures = failures;
+    }
+}

package/dist/src/source-files.js

@@ -3,45 +3,10 @@
  * in a document or a string names one: as the file itself, or as a file the
  * compiler emits from it.
  */
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-/** The source extensions the compiler emits each output extension from. */
-const EMITTED = [
-    { emitted: ".d.ts", sources: [".ts", ".tsx"] },
-    { emitted: ".d.mts", sources: [".mts"] },
-    { emitted: ".d.cts", sources: [".cts"] },
-    { emitted: ".js", sources: [".ts", ".tsx"] },
-    { emitted: ".jsx", sources: [".tsx"] },
-    { emitted: ".mjs", sources: [".mts"] },
-    { emitted: ".cjs", sources: [".cts"] },
-];
+import { commonDirectory, emittedFrom } from "./emit-map.js";
+import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
-/** One path with its extension replaced, where it carries the one named. */
-function reExtended(path, emitted, source) {
-    return path.endsWith(emitted) ? path.slice(0, path.length - emitted.length) + source : undefined;
-}
-/**
- * The longest directory every path shares, which is the directory the compiler
- * emits from where the configuration declares no root directory.
- */
-function commonDirectory(paths) {
-    const first = paths[0];
-    if (first === undefined) {
-        return "";
-    }
-    let common = dirnamePath(first).split("/");
-    for (const path of paths.slice(1)) {
-        const segments = dirnamePath(path).split("/");
-        let shared = 0;
-        while (shared < common.length &&
-            shared < segments.length &&
-            common[shared] === segments[shared]) {
-            shared += 1;
-        }
-        common = common.slice(0, shared);
-    }
-    return common.join("/");
-}
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -77,31 +42,9 @@ export function sourceFilesOf(project, targetRoot) {
     const outDir = at(options.outDir);
     const declarationDir = at(options.declarationDir);
     const sourceDir = at(options.rootDir) ?? commonDirectory([...byName.keys()]);
-    /** One path read below the directory the compiler emits from, where it is below the one it emits to. */
-    const fromEmit = (path, emitted) => {
-        const emitDir = emitted.startsWith(".d.") ? (declarationDir ?? outDir) : outDir;
-        if (emitDir === undefined) {
-            return undefined;
-        }
-        const below = relativePath(emitDir, path);
-        return below === undefined ? undefined : joinPath(sourceDir, below);
-    };
+    const layout = { outDir, declarationDir, sourceDirs: [sourceDir] };
     /** The source paths one written path may stand for, the path itself first. */
-    const candidates = (path) => {
-        const found = [path];
-        for (const { emitted, sources } of EMITTED) {
-            const mapped = fromEmit(path, emitted);
-            for (const source of sources) {
-                for (const from of [path, mapped]) {
-                    const candidate = from === undefined ? undefined : reExtended(from, emitted, source);
-                    if (candidate !== undefined) {
-                        found.push(candidate);
-                    }
-                }
-            }
-        }
-        return found;
-    };
+    const candidates = (path) => [path, ...emittedFrom(path, layout)];
     return {
         byPath,
         byName,

package/dist/src/sweep.js

@@ -153,13 +153,15 @@ function reachable(graph, held, mode) {
 function admitTestsOfDeadCode(graph, dead, held) {
     const admitted = graph.symbols.map(() => false);
     graph.symbols.forEach((_symbol, at) => {
-        if (graph.test[at] !== true || graph.subject[at] !== true || held[at] === true) {
+        const testCode = graph.test[at] === true || graph.support[at] === true;
+        if (!testCode || graph.subject[at] !== true || held[at] === true) {
             return;
         }
         let targets = 0;
         let live = 0;
         for (const edge of graph.out[at] ?? []) {
-            if (graph.test[edge.to] === true || graph.subject[edge.to] !== true) {
+            const target = graph.test[edge.to] === true || graph.support[edge.to] === true;
+            if (target || graph.subject[edge.to] !== true) {
                 continue;
             }
             targets += 1;

package/dist/src/template-field.js

@@ -11,9 +11,11 @@
  * instance members of classes and the members of interfaces and object types, on any
  * type, because nothing ties the name to a type.
  */
+import { readComponent } from "./component-files.js";
 import { ConfigError } from "./config.js";
 import { memberNames } from "./member-names.js";
-import { isAbsolutePath, joinPath, normalizePath } from "./paths.js";
+import { isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
+import { isComponentFile } from "./position.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
     "method",
@@ -21,6 +23,11 @@ const READ_BY_A_TEMPLATE = new Set([
     "interface-method",
     "type-member",
 ]);
+/**
+ * The kinds of declaration a component file's markup can name. Its expressions are the
+ * language's own, so a static member and an enum member are reachable by name too.
+ */
+const READ_BY_MARKUP = new Set([...READ_BY_A_TEMPLATE, "enum-member"]);
 /** One identifier, as the grammar of the analyzed language spells one. */
 const IDENTIFIER = /[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*/uy;
 /** Two strings ordered bytewise. */
@@ -133,6 +140,14 @@ function namesOf(text, delimiters) {
         from = close + delimiters.right.length;
     }
 }
+/** Every identifier the markup of one component file writes in an action. */
+function markupNamesOf(text) {
+    return readComponent(text).markup.flatMap((one) => identifiersOf(one.text).map(({ name, offset }) => ({
+        name,
+        offset: one.start + offset,
+        action: one.action,
+    })));
+}
 /** Where one offset of a template is, its column counted in UTF-16 code units. */
 function positionIn(file, offset) {
     const before = file.text.slice(0, offset);
@@ -146,25 +161,42 @@ function positionIn(file, offset) {
 /**
  * The template-field detector: every instance member of a class and every member of
  * an interface or an object type whose name an action of a configured template
- * writes, recorded at the identifier.
+ * writes, and every member of those and of an enum whose name a component file's
+ * markup writes, recorded at the identifier and held while that file is live.
  */
 export function templateField(input) {
     const { templates } = input;
-    if (templates.files.length === 0) {
+    const components = input.project.ownSourceFiles().flatMap((file) => {
+        const path = isComponentFile(file) ? relativePath(input.targetRoot, file.fileName) : undefined;
+        return path === undefined ? [] : [{ path, text: file.originalText }];
+    });
+    if (templates.files.length === 0 && components.length === 0) {
         return [];
     }
     const members = memberNames(input.project.ownSourceFiles(), input.held);
     const found = [];
-    for (const file of templates.files) {
-        for (const named of namesOf(file.text, templates.delimiters)) {
+    const scanned = [
+        ...templates.files.map((file) => ({
+            file,
+            names: namesOf(file.text, templates.delimiters),
+            markup: false,
+        })),
+        ...components.map((file) => ({ file, names: markupNamesOf(file.text), markup: true })),
+    ];
+    for (const { file, names, markup } of scanned) {
+        for (const named of names) {
             for (const member of members.get(named.name) ?? []) {
-                if (!READ_BY_A_TEMPLATE.has(member.kind) || member.static) {
+                const readable = markup
+                    ? READ_BY_MARKUP.has(member.kind)
+                    : READ_BY_A_TEMPLATE.has(member.kind) && !member.static;
+                if (!readable) {
                     continue;
                 }
                 found.push({
                     id: member.id,
                     detail: `named by ${named.action}`,
                     site: positionIn(file, named.offset),
+                    ...(markup ? { whileLive: file.path } : {}),
                 });
             }
         }

package/dist/src/test-support.js

@@ -0,0 +1,59 @@
+/**
+ * Test-support code: a file that is not a test file by name and that only test code
+ * imports. At least one test file reaches it, directly or through other such files, and
+ * nothing else does, so it is judged with the tests: what it references is referenced by
+ * test code, and a declaration of it is live while test code references it.
+ */
+/** The root kind that never takes a file out of test-support code: the skip only withholds. */
+const SKIP_ROOT = "type-error";
+/**
+ * The files of one project that are test-support code, below the target root. A file
+ * holding a root is not one, because a root has a caller outside the import graph: a
+ * runtime, a tool, a configuration, or a consumer of a library's published API.
+ * `testFiles` are the files the test-file rules classified.
+ */
+export function testSupportFiles(symbols, references, roots, testFiles) {
+    const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
+    const users = new Map();
+    for (const reference of references) {
+        const used = fileOf.get(reference.to);
+        const from = reference.position.path;
+        if (reference.consumer !== undefined || used === undefined || used === from) {
+            continue;
+        }
+        const held = users.get(used);
+        if (held === undefined) {
+            users.set(used, new Set([from]));
+        }
+        else {
+            held.add(from);
+        }
+    }
+    const tests = new Set(testFiles);
+    const rooted = new Set(roots.filter((root) => root.kind !== SKIP_ROOT).flatMap((root) => fileOf.get(root.id) ?? []));
+    const candidates = [...users.keys()].filter((path) => !tests.has(path) && !rooted.has(path));
+    const support = new Set();
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const path of candidates) {
+            if (support.has(path)) {
+                continue;
+            }
+            const from = users.get(path) ?? new Set();
+            if ([...from].every((one) => tests.has(one) || support.has(one))) {
+                support.add(path);
+                changed = true;
+            }
+        }
+    }
+    return support;
+}
+/** The references with every one a test-support file makes counted as a test reference. */
+export function supportReferences(references, support) {
+    if (support.size === 0) {
+        return references;
+    }
+    return references.map((reference) => !reference.test && support.has(reference.position.path)
+        ? { ...reference, test: true }
+        : reference);
+}