@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/dist/src/destructuring.js

@@ -6,8 +6,10 @@
  * it. A rest element names no property: what it copies is read where the copy is.
  */
 import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { TypeFlags } from "@typescript/native/sync";
+import { SignatureKind, TypeFlags, } from "@typescript/native/sync";
 import { isAnswered, propertyTables, UNANSWERED, } from "./query.js";
+/** The types of an iteration result's `value` that carry no element of the iterable. */
+const NO_ELEMENT = TypeFlags.AnyOrUnknown | TypeFlags.Undefined | TypeFlags.Void | TypeFlags.Null | TypeFlags.Never;
 /** The text a property name spells, or `undefined` for a computed name. */
 function nameText(node) {
     if (node === undefined) {
@@ -207,11 +209,84 @@ export function destructuring(project, cap, properties = propertyTables(project.
         const elements = queries.typeArguments(type);
         return isAnswered(elements) ? elements[0] : UNANSWERED;
     };
+    /** The type of the one property of a type that `matches` accepts, unanswered where two do. */
+    const propertyTypeOf = (owner, matches) => {
+        const table = tableOf(owner);
+        if (!isAnswered(table)) {
+            return UNANSWERED;
+        }
+        const [property, ...more] = [...table.values()].filter(matches);
+        if (property === undefined) {
+            return undefined;
+        }
+        if (more.length > 0) {
+            return UNANSWERED;
+        }
+        patternLookups += 1;
+        return queries.typeOfSymbol(property);
+    };
+    const resultOf = (callee) => {
+        if (callee === undefined || callee === UNANSWERED) {
+            return callee;
+        }
+        patternLookups += 1;
+        const signatures = queries.signaturesOf(callee, SignatureKind.Call);
+        if (!isAnswered(signatures)) {
+            return UNANSWERED;
+        }
+        const [signature] = signatures;
+        if (signature === undefined) {
+            return undefined;
+        }
+        patternLookups += 1;
+        return queries.returnTypeOf(signature);
+    };
+    const iterations = new Map();
+    /**
+     * The type a `for…of` takes from one iterable that is no array, read through the
+     * iteration protocol: the `value` of what the `next()` of its `[Symbol.iterator]()`
+     * answers. A constituent of that answer whose value is {@link NO_ELEMENT} carries no
+     * element; where more than one carries one, the element is left unanswered, so a read
+     * through it is resolved by name.
+     */
+    const iteratedOf = (type) => {
+        if (iterations.has(type.id)) {
+            return iterations.get(type.id);
+        }
+        // The checker keys a member a unique symbol names `__@<name>@<symbol id>`, and escapes
+        // a written key that starts with `__` with one more `_`, so no string key matches; a
+        // unique symbol of the program's own named `iterator` does, which leaves two matches:
+        // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/checker/checker.go#L23096-L23108
+        // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/ast/symbol.go#L91-L103
+        const iterator = resultOf(propertyTypeOf(type, (one) => one.escapedName.startsWith("__@iterator@")));
+        const result = iterator === undefined || iterator === UNANSWERED
+            ? iterator
+            : resultOf(propertyTypeOf(iterator, (one) => one.name === "next"));
+        let found = result;
+        if (result !== undefined && result !== UNANSWERED) {
+            let parts = [result];
+            if (result.isUnionType()) {
+                patternLookups += 1;
+                parts = queries.constituents(result);
+            }
+            const values = isAnswered(parts)
+                ? parts.map((part) => propertyTypeOf(part, (one) => one.name === "value"))
+                : [UNANSWERED];
+            const carried = values.filter((value) => value === UNANSWERED || (value !== undefined && (value.flags & NO_ELEMENT) === 0));
+            const [only, ...more] = carried;
+            found = more.length > 0 ? UNANSWERED : only;
+        }
+        iterations.set(type.id, found);
+        return found;
+    };
     const step = (type, next) => {
         const defined = definedOf(type);
         if (defined === undefined || defined === UNANSWERED) {
             return defined;
         }
+        if (next.kind === "iterated") {
+            return elementOf(defined, undefined) ?? iteratedOf(defined);
+        }
         if (next.kind === "property") {
             const table = tableOf(defined);
             if (!isAnswered(table)) {
@@ -224,7 +299,7 @@ export function destructuring(project, cap, properties = propertyTables(project.
             patternLookups += 1;
             return queries.typeOfSymbol(property);
         }
-        return elementOf(defined, next.kind === "element" ? next.index : undefined);
+        return elementOf(defined, next.index);
     };
     const resolve = (reads) => {
         const patterns = [...new Set(reads.map((read) => read.pattern))];

package/dist/src/discover.js

@@ -1,6 +1,8 @@
 import { DiagnosticCategory } from "@typescript/native/sync";
+import { baseUrlPaths } from "./base-url.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { SetupError } from "./setup-failure.js";
+import { writtenPath } from "./workspace-programs.js";
 /** Directory names discovery does not descend into. */
 export const IGNORED_DIRECTORIES = new Set(["node_modules", ".git"]);
 /** A compiler configuration file discovery recognises under a root. */
@@ -60,12 +62,35 @@ function locatedIn(diagnostics, locate) {
 export function diagnosticErrors(sets) {
     return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
 }
+/**
+ * The codes of a type library and a lib the configuration names that the compiler
+ * cannot find, which it reports while it gathers the program's files,
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/compiler/processingDiagnostic.go,
+ * and {@link MISSING_GLOBAL_TYPE}, which the checker reports.
+ */
+const UNFOUND_LIBRARY = new Set([2318, 2688, 2726, 2727]);
+/**
+ * The code of a global type the checker finds in no library the program holds. The checker
+ * types every use of one against nothing and places no error in the file, so the analysis
+ * skips each file of such a project whole.
+ */
+export const MISSING_GLOBAL_TYPE = 2318;
 /** The errors one open project carries, each located in the file it names. */
 export function projectErrors(sets) {
-    const load = sets.configParsing.filter(isError);
+    // The compiler numbers its semantic messages from 2000 and its option messages from
+    // 5000. A file-less option error, a removed option or an output layout, leaves the
+    // program whole, and the compiler checks it all the same:
+    // https://github.com/microsoft/TypeScript/wiki/Coding-guidelines#diagnostic-message-codes
+    const semantic = sets.unplaced.filter((diagnostic) => isError(diagnostic) && diagnostic.code >= 2000 && diagnostic.code < 3000);
+    const unfound = semantic.filter(({ code }) => UNFOUND_LIBRARY.has(code));
+    const load = [
+        ...sets.configParsing.filter(isError),
+        ...semantic.filter(({ code }) => !UNFOUND_LIBRARY.has(code)),
+    ];
     return {
         load: locatedIn(load, sets.locate),
         check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
+        unfound: load.length > 0 ? [] : locatedIn(unfound, sets.locate),
     };
 }
 /**
@@ -86,9 +111,6 @@ export function targetRelative(text, targetRoot) {
 export function isGuess(discovery, configFile) {
     return discovery.derived && !discovery.fromScope.includes(configFile);
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /**
  * The configuration files below `root`, in ascending path order, skipping an
  * ignored directory. A directory that cannot be read is skipped: a tree the
@@ -124,46 +146,6 @@ function configFilesUnder(host, root) {
     }
     return found.sort();
 }
-/**
- * The configuration files one configuration's `references` name, resolved against
- * that configuration's own directory. A reference naming a directory names the
- * `tsconfig.json` in it, which is the compiler's own rule.
- */
-function referencesOf(host, configFile) {
-    let text;
-    try {
-        text = host.readFile(configFile);
-    }
-    catch {
-        return [];
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        // What a configuration's contents say is refused by the compiler's own
-        // diagnostics, which name the position; nothing is inferred from it here.
-        return [];
-    }
-    if (!isRecord(value) || !Array.isArray(value["references"])) {
-        return [];
-    }
-    const dir = dirnamePath(configFile);
-    const found = [];
-    for (const entry of value["references"]) {
-        if (!isRecord(entry)) {
-            continue;
-        }
-        const path = entry["path"];
-        if (typeof path !== "string" || path === "") {
-            continue;
-        }
-        const resolved = isAbsolutePath(path) ? path : joinPath(dir, path);
-        found.push(resolved.endsWith(".json") ? resolved : joinPath(resolved, "tsconfig.json"));
-    }
-    return found;
-}
 /**
  * The configuration file the scope names for the target directly, where its path
  * names one rather than a directory. A target naming a directory is reached by the
@@ -177,12 +159,12 @@ function scopeConfigFiles(host, scope) {
 }
 /**
  * Every configuration file reached from `pending`, in the order discovery reads them:
- * each once, each followed by the configurations it references, transitively. A
- * configuration the compiler cannot read ends the run naming it, unless `unreadable`
- * is given, which is then told the configuration and why, and the walk goes on
- * without it.
+ * each once, each followed by the configurations it references that `follows` admits,
+ * transitively. A configuration the compiler cannot read ends the run naming it, unless
+ * `unreadable` is given, which is then told the configuration and why, and the walk
+ * goes on without it.
  */
-function derivedFrom(engine, host, pending, unreadable) {
+function derivedFrom(engine, host, pending, follows, unreadable) {
     const seen = new Set();
     const found = [];
     while (pending.length > 0) {
@@ -195,16 +177,16 @@ function derivedFrom(engine, host, pending, unreadable) {
             continue;
         }
         seen.add(path);
-        const reason = unreadableReason(engine, path);
-        if (reason !== undefined) {
+        const read = readConfiguration(engine, path);
+        if ("reason" in read) {
             if (unreadable === undefined) {
-                throw new DiscoveryError(`${path} cannot be read as a compiler configuration: ${reason}`, []);
+                throw new DiscoveryError(`${path} cannot be read as a compiler configuration: ${read.reason}`, []);
             }
-            unreadable(path, reason);
+            unreadable(path, read.reason);
             continue;
         }
         found.push(path);
-        pending.push(...referencesOf(host, path));
+        pending.push(...read.references.filter(follows));
     }
     return found;
 }
@@ -229,7 +211,7 @@ export function consumerProjects(engine, host, root) {
     if (kind !== "directory") {
         throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
     }
-    const found = derivedFrom(engine, host, configFilesUnder(host, root));
+    const found = derivedFrom(engine, host, configFilesUnder(host, root), () => true);
     if (found.length === 0) {
         throw new DiscoveryError(`the consumer ${root} holds no compiler configuration, so none of its references can be read`, []);
     }
@@ -242,42 +224,130 @@ export function consumerProjects(engine, host, root) {
 function derivedId(targetRoot, configFile) {
     return relativePath(targetRoot, configFile) ?? configFile;
 }
-/** Why the compiler cannot read one configuration file, or undefined where it can. */
-function unreadableReason(engine, configFile) {
-    try {
-        engine.parseConfigFile(configFile);
+/**
+ * The code of a configuration whose `extends` chain returns to a configuration it already
+ * passed. The parse reports it and returns, and a snapshot opened from it never answers:
+ * https://github.com/microsoft/TypeScript/issues/64754
+ */
+const CIRCULAR_EXTENDS = 18000;
+/** The configuration files one parsed configuration's own `extends` names by path. */
+function extendedPaths(parsed, configFile) {
+    const { raw } = parsed;
+    const named = typeof raw === "object" && raw !== null ? Reflect.get(raw, "extends") : [];
+    return (Array.isArray(named) ? named : [named])
+        .filter((one) => typeof one === "string")
+        .filter((one) => one.startsWith("./") || one.startsWith("../") || isAbsolutePath(one))
+        .map((one) => resolvePath(dirnamePath(configFile), one));
+}
+/**
+ * The `extends` chain from `configFile` to the first configuration it reaches twice, each
+ * link by path, or undefined where no chain written by path returns.
+ */
+function extendsCycle(engine, configFile, parsed) {
+    const walk = (chain, at) => {
+        for (const next of extendedPaths(at, chain.at(-1) ?? configFile)) {
+            if (chain.includes(next)) {
+                return [...chain, next];
+            }
+            let read;
+            try {
+                read = engine.parseConfigFile(next);
+            }
+            catch {
+                continue;
+            }
+            const cycle = walk([...chain, next], read);
+            if (cycle !== undefined) {
+                return cycle;
+            }
+        }
         return undefined;
+    };
+    return walk([configFile], parsed);
+}
+/** The configuration files one parsed configuration's `references` name. */
+function referencesOf(parsed) {
+    // The parse answers a directory reference as the directory; the compiler reads a
+    // path not ending `.json` as its `tsconfig.json`:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
+    return (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"));
+}
+/** Why one parsed configuration's own `extends` chain cannot be opened, where it is circular. */
+function circularity(engine, configFile, parsed) {
+    const chain = extendsCycle(engine, configFile, parsed);
+    if (chain === undefined && !parsed.errors.some(({ code }) => code === CIRCULAR_EXTENDS)) {
+        return undefined;
+    }
+    return `TS${String(CIRCULAR_EXTENDS)}: Circularity detected while resolving configuration: ${(chain ?? [configFile]).join(" -> ")}`;
+}
+/**
+ * Why a configuration the `references` reach, transitively, cannot be opened, where one's
+ * `extends` chain is circular: the compiler opens every referenced project with the one
+ * that references it.
+ */
+function referencedCircularity(engine, references, visited) {
+    for (const reference of references) {
+        if (visited.has(reference)) {
+            continue;
+        }
+        visited.add(reference);
+        let parsed;
+        try {
+            parsed = engine.parseConfigFile(reference);
+        }
+        catch {
+            continue;
+        }
+        const reason = circularity(engine, reference, parsed) ??
+            referencedCircularity(engine, referencesOf(parsed), visited);
+        if (reason !== undefined) {
+            return reason;
+        }
+    }
+    return undefined;
+}
+/**
+ * The configuration files one configuration's `references` name, or why the compiler
+ * cannot read the configuration: it throws, or its `extends` chain or that of a
+ * configuration it references is circular, which the analysis refuses before any
+ * snapshot is asked to open it.
+ */
+function readConfiguration(engine, configFile) {
+    try {
+        const parsed = engine.parseConfigFile(configFile);
+        const references = referencesOf(parsed);
+        const reason = circularity(engine, configFile, parsed) ??
+            referencedCircularity(engine, references, new Set([configFile]));
+        return reason === undefined ? { references } : { reason };
     }
     catch (error) {
-        return error instanceof Error ? error.message : String(error);
+        return { reason: error instanceof Error ? error.message : String(error) };
     }
 }
 /**
- * Resolves one compiler configuration file, or ends the run naming it: a project
- * opened from a configuration the compiler cannot read would be analyzed with no
- * type information.
+ * The references of one compiler configuration file, or ends the run naming it: a
+ * project opened from a configuration the compiler cannot read would be analyzed with
+ * no type information.
  */
 function parseOrRefuse(engine, configFile, named) {
-    const reason = unreadableReason(engine, configFile);
-    if (reason !== undefined) {
-        throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${reason}`, []);
+    const read = readConfiguration(engine, configFile);
+    if ("reason" in read) {
+        throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${read.reason}`, []);
     }
+    return read.references;
 }
 /**
- * The projects a build matrix declares, in the order it lists them. Each entry
- * names a file below the target root, and an entry naming a file that is absent,
- * that is a directory, or that the compiler cannot read ends the run naming it.
- *
- * A declared project's `references` are not followed, because the entries are the
- * matrix, and a reference to a configuration the matrix does not name ends the run
- * naming both: the compiler builds a referenced project's sources into the program
- * that references it without reporting their diagnostics, so the project the matrix
- * left out would be analyzed with its errors unread. An entry naming a file an
- * earlier entry named adds nothing, so the earlier identifier stands.
+ * The projects a build matrix declares, in its order, each entry a file below the target
+ * root: an entry naming an absent file, a directory or a file the compiler cannot read
+ * ends the run naming it, and one naming an earlier entry's file adds nothing. A
+ * reference below the root the matrix does not name ends the run naming both, because the
+ * compiler builds a referenced project's sources into the referencing program without
+ * reporting their diagnostics. A reference outside the root is an outside project.
  */
 function declaredProjects(engine, host, targetRoot, entries) {
     const seen = new Set();
     const projects = [];
+    const references = new Map();
     for (const entry of entries) {
         const configFile = joinPath(targetRoot, entry.project);
         const named = `the project ${JSON.stringify(entry.id)} (${configFile})`;
@@ -291,11 +361,13 @@ function declaredProjects(engine, host, targetRoot, entries) {
             continue;
         }
         seen.add(configFile);
-        parseOrRefuse(engine, configFile, named);
+        references.set(configFile, parseOrRefuse(engine, configFile, named));
         projects.push({ id: entry.id, configFile });
     }
     for (const project of projects) {
-        const unnamed = referencesOf(host, project.configFile).find((path) => !seen.has(path));
+        const unnamed = references
+            .get(project.configFile)
+            ?.find((path) => !seen.has(path) && relativePath(targetRoot, path) !== undefined);
         if (unnamed !== undefined) {
             throw new DiscoveryError(`the project ${JSON.stringify(project.id)} (${project.configFile}) references ` +
                 `${unnamed}, which the build matrix does not name. A referenced project is built ` +
@@ -311,18 +383,19 @@ function declaredProjects(engine, host, targetRoot, entries) {
     };
 }
 /**
- * The projects a run derives where the matrix declares none, in the order discovery
- * reads them: the paths the scope names, then every compiler configuration under
- * the target root that is not inside an ignored directory, then the configurations
- * each of those references, transitively. Each configuration appears once. A
- * configuration the scope names directly is the caller's own and ends the run where
- * it cannot be read; one the walk found is dropped and named.
+ * The projects a run derives where the matrix declares none, in discovery order: the
+ * paths the scope names, every compiler configuration under the target root outside an
+ * ignored directory, then each configuration below the root those reference,
+ * transitively, each once. A reference outside the root is an outside project, whose
+ * sources the compiler builds into the referencing program. A configuration the scope
+ * names ends the run where it cannot be read; one the walk found is dropped and named.
  */
 function derivedProjects(engine, host, scope) {
     const targetRoot = scope.target.path;
     const fromScope = scopeConfigFiles(host, scope);
     const notBuilt = [];
-    const configFiles = derivedFrom(engine, host, [...fromScope, ...configFilesUnder(host, targetRoot)], (configFile, reason) => {
+    const rootDir = resolvePath(host.workingDirectory(), fromScope.length > 0 ? dirnamePath(targetRoot) : targetRoot);
+    const configFiles = derivedFrom(engine, host, [...fromScope, ...configFilesUnder(host, targetRoot)], (reference) => relativePath(rootDir, reference) !== undefined, (configFile, reason) => {
         if (fromScope.includes(configFile)) {
             throw new DiscoveryError(`${configFile} cannot be read as a compiler configuration: ${reason}`, []);
         }
@@ -363,3 +436,33 @@ export function discoverProjects(engine, host, scope, configurations = []) {
     }
     return derivedProjects(engine, host, scope);
 }
+/**
+ * How the snapshot reads each configuration of `configFiles` that sets `baseUrl` and
+ * `programs` does not already describe: a configuration only the snapshot holds, which
+ * extends it and states the `paths` {@link baseUrlPaths} gives, so its imports resolve as
+ * the compilers before version 7 resolve them. A configuration the compiler cannot read is
+ * left for its project to refuse.
+ */
+export function withBaseUrlPaths(engine, host, configFiles, programs) {
+    const found = new Map(programs);
+    for (const configFile of configFiles) {
+        if (found.has(configFile)) {
+            continue;
+        }
+        let paths;
+        try {
+            paths = baseUrlPaths(engine.parseConfigFile(configFile).options);
+        }
+        catch {
+            continue;
+        }
+        if (paths !== undefined) {
+            found.set(configFile, {
+                kind: "configuration",
+                file: writtenPath(host, configFile),
+                text: `${JSON.stringify({ extends: configFile, compilerOptions: { paths } }, null, 2)}\n`,
+            });
+        }
+    }
+    return found;
+}

package/dist/src/edges.js

@@ -130,7 +130,7 @@ export function readEdgeSides(host, targetRoot) {
     }
     const sides = [];
     edges.forEach((value, index) => {
-        const offset = walk.opened[index];
+        const offset = walk.starts[index];
         const at = offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
         const edge = readEdge(value, at);
         const named = [

package/dist/src/entry-point-gaps.js

@@ -43,7 +43,6 @@ const UNREAD_TOOLS = [
     "cypress",
     "danger",
     "dependency-cruiser",
-    "docusaurus",
     "dotenv",
     "drizzle",
     "electron-vite",
@@ -97,14 +96,12 @@ const UNREAD_TOOLS = [
     "nuxtjs-i18n",
     "nx",
     "nyc",
-    "oclif",
     "openapi-ts",
     "openclaw",
     "orval",
     "oxfmt",
     "oxlint",
     "panda-css",
-    "parcel",
     "payload",
     "pino",
     "playwright-ct",
@@ -149,7 +146,6 @@ const UNREAD_TOOLS = [
     "swc",
     "syncpack",
     "tailwind",
-    "tanstack-router",
     "taskfile",
     "tauri",
     "temporal",
@@ -193,18 +189,19 @@ const UNREAD_TOOLS = [
 ];
 /** The conventions declined for a tool some of whose conventions are entered. */
 const PARTLY_ENTERED = [
+    {
+        tool: "docusaurus",
+        convention: "a page or theme directory a plugin's configuration moves, and the docs",
+        reason: "The convention row reads src/pages and src/theme only, and a document's imports are " +
+            "read from every Markdown and MDX file, so a module only a moved directory holds is " +
+            "reported as never imported unless ts.entry_files names it.",
+    },
     {
         tool: "eslint",
         convention: "a legacy configuration written in YAML or in JSON with comments",
         reason: "Only a configuration module and a strict JSON configuration file are read, so a " +
             "dependency only such a file names is reported as unused.",
     },
-    {
-        tool: "eslint",
-        convention: "a plugin or shareable configuration named without its package's prefix",
-        reason: "A string uses a dependency only where it spells the dependency's name, so a " +
-            "dependency only a shortened name loads is reported as unused.",
-    },
     {
         tool: "playwright",
         convention: "a testMatch written as a regular expression",