@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/dist/src/roots/configured-declarations.js

@@ -140,6 +140,9 @@ function specifierOf(node) {
  * import resolves. A specifier no file writes resolves to no module.
  */
 function modulesNamed(project, specifiers) {
+    if (specifiers.size === 0) {
+        return new Map();
+    }
     const written = new Map();
     for (const file of project.ownSourceFiles()) {
         const visit = (node) => {

package/dist/src/roots/published-reach.js

@@ -182,7 +182,7 @@ function declarationNodes(held, byPath) {
     return {
         typeNamesOf: (symbol) => {
             const { byId, nodes } = nodesIn(symbol.position.path);
-            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
+            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, (nested) => nodes.has(nested)));
         },
         nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
     };
@@ -369,12 +369,12 @@ function inferredTypeSymbols(project, declarations) {
 /**
  * The names of types one declaration's own syntax writes: in a type reference, a
  * heritage clause or a type query. A function body is not read, and neither is a
- * declaration nested in this one, which `nested` holds and which is read on its own.
+ * declaration nested in this one that `readAlone` says is read on its own.
  */
-function typeNamesOf(declaration, nested) {
+export function typeNamesOf(declaration, readAlone) {
     const found = [];
     const visit = (node) => {
-        if (node !== declaration && nested.has(node)) {
+        if (node !== declaration && readAlone(node)) {
             return;
         }
         if (isTypeReferenceNode(node)) {

package/dist/src/roots/root-set.js

@@ -389,7 +389,7 @@ export function rootSet(project, held, targetRoot, options) {
     for (const id of skippedRoots(project, held, options.skips)) {
         add(id, "type-error", "");
     }
-    for (const id of mergedGlobalInterfaces(project, held, files)) {
+    for (const id of mergedGlobalInterfaces(project, held, files).kept) {
         add(id, "global-augmentation", "");
     }
     return {

package/dist/src/roots/unseen-loads.js

@@ -4,9 +4,10 @@
  * are never complete.
  */
 import { isBinaryExpression, isCallExpression, isIdentifier, isMetaProperty, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { amdLoadOf, amdUnresolved } from "../amd.js";
 import { membersNamed, textsOf, writtenValue } from "../entries/static-module.js";
 import { writtenName } from "../platform-calls.js";
-import { dirnamePath, relativePath, resolvePath } from "../paths.js";
+import { cannotStartPackageName, dirnamePath, hasURLScheme, isAbsolutePath, relativePath, resolvePath, startsRelativePath, } from "../paths.js";
 import { unwrapped } from "../unwrap.js";
 import { globExpression } from "../text/glob.js";
 /** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
@@ -29,7 +30,7 @@ function leadingLiteral(node) {
  * it, each of which would name every sibling.
  */
 function computedLoadDirectory(dir, prefix) {
-    if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !prefix.endsWith("/")) {
+    if (!startsRelativePath(prefix) || !prefix.endsWith("/")) {
         return undefined;
     }
     const target = resolvePath(dir, prefix);
@@ -65,7 +66,7 @@ function globbed(file, first, options, others, rootOf) {
     const dir = dirnamePath(file.fileName);
     const root = () => rootOf(file.fileName);
     const against = (at) => {
-        if (!at.startsWith("/")) {
+        if (!isAbsolutePath(at)) {
             return resolvePath(dir, at);
         }
         const top = root();
@@ -78,10 +79,10 @@ function globbed(file, first, options, others, rootOf) {
         const negated = written.startsWith("!");
         const pattern = negated ? written.slice(1) : written;
         let path;
-        if (pattern.startsWith("/")) {
+        if (isAbsolutePath(pattern)) {
             path = against(pattern);
         }
-        else if (pattern.startsWith("./") || pattern.startsWith("../")) {
+        else if (startsRelativePath(pattern)) {
             path = from === undefined ? undefined : resolvePath(from, pattern);
         }
         else if (pattern.startsWith("**")) {
@@ -100,7 +101,8 @@ function globbed(file, first, options, others, rootOf) {
  * file itself: an `import()` or `require()` whose path starts with a relative literal naming
  * a directory below the file's loads every candidate below it, as a bundler's context module
  * reads it, and an `import.meta.glob` every candidate its globs match ({@link globbed}). A
- * call of a computed path that names no such directory and no package is an unresolved load.
+ * call of a computed path that names no such directory and no package is an unresolved load,
+ * and so is an AMD call one of whose dependencies names no path ({@link amdUnresolved}).
  */
 export function computedLoadsOf(file, calls, candidates, rootOf) {
     const dir = dirnamePath(file.fileName);
@@ -118,6 +120,7 @@ export function computedLoadsOf(file, calls, candidates, rootOf) {
                     call,
                     from,
                     require: undefined,
+                    amd: false,
                     files: files ?? [],
                     resolved: files !== undefined,
                     asset,
@@ -125,6 +128,23 @@ export function computedLoadsOf(file, calls, candidates, rootOf) {
                 },
             ];
         }
+        const amd = amdLoadOf(call);
+        if (amd !== undefined) {
+            return amdUnresolved(amd)
+                ? [
+                    {
+                        call,
+                        from,
+                        require: amd.callee,
+                        amd: true,
+                        files: [],
+                        resolved: false,
+                        asset: false,
+                        eager: false,
+                    },
+                ]
+                : [];
+        }
         const argument = unwrapped(first);
         const require = call.expression.kind === SyntaxKind.ImportKeyword ? undefined : writtenName(call.expression);
         if (!mayNamePath(argument)) {
@@ -139,7 +159,16 @@ export function computedLoadsOf(file, calls, candidates, rootOf) {
             ? []
             : others.filter((candidate) => relativePath(target, candidate.file.fileName) !== undefined);
         return [
-            { call, from, require, files, resolved: target !== undefined, asset: false, eager: false },
+            {
+                call,
+                from,
+                require,
+                amd: false,
+                files,
+                resolved: target !== undefined,
+                asset: false,
+                eager: false,
+            },
         ];
     });
 }
@@ -202,7 +231,6 @@ function readsAsAsset(options) {
 function namesPackage(prefix) {
     return (prefix !== undefined &&
         prefix !== "" &&
-        !prefix.startsWith(".") &&
-        !prefix.startsWith("/") &&
-        !/^[A-Za-z][A-Za-z\d+.-]*:/u.test(prefix));
+        !cannotStartPackageName(prefix) &&
+        !hasURLScheme(prefix));
 }

package/dist/src/serialization-contract.js

@@ -898,7 +898,8 @@ export function serializationContract(input) {
 }
 /**
  * The data members the decodes and copies of `files` fill, as {@link Decoded} names them.
- * A generic declared outside the analysis, or only ambiently, fills the type that a type
+ * A generic declared outside the analysis, or only ambiently, or one that reads a value
+ * {@link readTypes} finds untyped as its own type parameter, fills the type that a type
  * parameter of its own no parameter names binds, where the awaited result carries that
  * type through its data members rather than only naming it, as a store's methods do: no
  * argument hands the value over, so it fills it where the analysis cannot see, and may
@@ -951,6 +952,10 @@ function decodedOf(project, held, files, consumers) {
     for (const file of files) {
         file.forEachChild(visit);
     }
+    const read = readTypes(project, untyped);
+    // A generic of the analysis that reads an untyped value as its own type parameter is a
+    // client of what made the value, and fills what that parameter binds as an outside one does.
+    const clients = new Set(read.made.flatMap((type) => (type.isTypeParameter() ? [type.id] : [])));
     const filled = [];
     const resolved = queries.resolvedSignatures(calls).map(must);
     for (const signature of resolved) {
@@ -963,7 +968,8 @@ function decodedOf(project, held, files, consumers) {
         const node = declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
         if (declaration === undefined ||
             (inAnalysis(declaration.path) &&
-                (node === undefined || (node.flags & NodeFlags.Ambient) === 0))) {
+                (node === undefined || (node.flags & NodeFlags.Ambient) === 0) &&
+                !generic.some((id) => clients.has(id)))) {
             continue;
         }
         const result = must(queries.returnTypeOf(declared));
@@ -982,7 +988,6 @@ function decodedOf(project, held, files, consumers) {
             filled.push({ carried: awaited(project, given), types });
         }
     }
-    const read = readTypes(project, untyped);
     const copies = copiedNames(project, spreads, calls);
     if (filled.length === 0 &&
         read.parsed.length === 0 &&

package/dist/src/stores.js

@@ -5,6 +5,7 @@
  */
 import { isGetAccessorDeclaration, isSetAccessorDeclaration, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
+import { classedAsTest, madeByTestCode, withheldBy } from "./tests/file-class.js";
 /** The class members one project's own files declare by a getter or a setter. */
 export function accessorsOf(project, held) {
     const found = [];
@@ -25,9 +26,10 @@ export function accessorsOf(project, held) {
 /** The run's stores, from what each configuration contributed, the records and the mode. */
 export function storesOf(per, exempt, mode) {
     return {
-        references: per.flatMap((one) => one.references.filter((reference) => !mode.production || !reference.test)),
+        references: per.flatMap((one) => one.references.filter((reference) => !withheldBy(mode, reference, one.support))),
         readInTests: new Set(per.flatMap((one) => one.references
-            .filter((reference) => reference.test && reference.use !== "write")
+            .filter((reference) => reference.use !== "write" &&
+            classedAsTest(madeByTestCode(reference, one.support), reference.consumer !== undefined, mode))
             .map((reference) => reference.to))),
         accessors: new Set(per.flatMap((one) => one.accessors)),
         exempt: new Set(exempt.map((record) => record.id)),

package/dist/src/symbol-keys.js

@@ -7,9 +7,7 @@
  */
 import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
 import { parenthesesRemoved } from "./unwrap.js";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
-import { isAnswered } from "./query.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument) {
     const at = parenthesesRemoved(argument);
@@ -127,87 +125,95 @@ function wellKnownName(name) {
         : undefined;
 }
 /**
- * The references the iterations of one project's own files make to the iteration members
- * of the values they iterate: a `for…of` statement and a spread element read
- * `[Symbol.iterator]`, and a `for await…of` statement reads `[Symbol.asyncIterator]` and,
- * which it falls back to, `[Symbol.iterator]`. Each is made by the declaration holding it.
+ * The reads the iterations of a side's files make of the iteration members of the values they
+ * iterate: a `for…of` statement and a spread element read `[Symbol.iterator]`, and a
+ * `for await…of` statement reads `[Symbol.asyncIterator]` and, which it falls back to,
+ * `[Symbol.iterator]`. Each is made by the declaration holding it. A value whose type or
+ * members the checker leaves unanswered holds the members those names could spell.
  */
-export function iterationReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const ownPaths = project.ownPaths();
-    const iterated = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            if (isForOfStatement(node)) {
-                const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
-                iterated.push({ file, from: holder, operand: node.expression, protocols });
-            }
-            else if (isSpreadElement(node)) {
-                iterated.push({ file, from: holder, operand: node.expression, protocols: ["iterator"] });
-            }
-            node.forEachChild((child) => {
-                visit(child, holder);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (iterated.length === 0) {
-        return [];
-    }
-    const types = queries.typesAt(iterated.map((one) => one.operand));
-    const members = new Map();
-    const membersOf = (type) => {
-        const known = members.get(type.id);
-        if (known !== undefined) {
-            return known;
-        }
-        const keyed = [];
-        const properties = queries.propertiesOf(type);
-        for (const property of isAnswered(properties) ? properties : []) {
-            for (const handle of property.declarations) {
-                const node = ownPaths.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
-                const name = wellKnownName(node?.name);
-                if (name !== undefined) {
-                    keyed.push({ name, ids: chains.declarationsOf(property) });
-                    break;
+export const iteration = {
+    start() {
+        const iterated = [];
+        return {
+            visit(node, { file, from }) {
+                if (isForOfStatement(node)) {
+                    const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
+                    iterated.push({ file, from, operand: node.expression, protocols });
                 }
-            }
-        }
-        members.set(type.id, keyed);
-        return keyed;
-    };
-    const found = [];
-    iterated.forEach((one, index) => {
-        const type = types[index];
-        if (type === undefined || !isAnswered(type)) {
-            return;
-        }
-        const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
-        const position = renderPosition(one.file, root, one.operand.getStart());
-        for (const part of isAnswered(parts) ? parts : []) {
-            for (const member of membersOf(part)) {
-                if (!one.protocols.includes(member.name)) {
-                    continue;
+                else if (isSpreadElement(node)) {
+                    iterated.push({ file, from, operand: node.expression, protocols: ["iterator"] });
                 }
-                for (const to of member.ids) {
-                    found.push({
-                        from: one.from,
-                        to,
-                        position,
-                        use: "read",
-                        resolution: "keyed",
-                        test: testFiles.has(position.path),
-                    });
+            },
+            reads({ project, chains }) {
+                const found = [];
+                if (iterated.length === 0) {
+                    return found;
                 }
-            }
-        }
-    });
-    return found;
-}
+                const queries = project.queries;
+                const ownPaths = project.ownPaths();
+                const types = queries.typesAt(iterated.map((one) => one.operand));
+                const members = new Map();
+                const membersOf = (type) => {
+                    const known = members.get(type.id);
+                    if (known !== undefined) {
+                        return known;
+                    }
+                    const properties = queries.propertiesOf(type);
+                    const keyed = [];
+                    for (const property of isAnswered(properties) ? properties : []) {
+                        for (const handle of property.declarations) {
+                            const node = ownPaths.has(handle.path)
+                                ? project.declarationAt(handle)?.node
+                                : undefined;
+                            const name = wellKnownName(node?.name);
+                            if (name !== undefined) {
+                                keyed.push({ name, ids: chains.declarationsOf(property) });
+                                break;
+                            }
+                        }
+                    }
+                    const result = isAnswered(properties) ? keyed : UNANSWERED;
+                    members.set(type.id, result);
+                    return result;
+                };
+                // A member a well-known symbol keys is named by the symbol's computed name.
+                const spelled = (protocols) => protocols.map((protocol) => `Symbol.${protocol}`);
+                iterated.forEach((one, index) => {
+                    const type = types[index];
+                    if (type === UNANSWERED) {
+                        found.push({ kind: "held", from: one.from, names: spelled(one.protocols) });
+                        return;
+                    }
+                    if (type === undefined) {
+                        return;
+                    }
+                    const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
+                    for (const part of isAnswered(parts) ? parts : [type]) {
+                        const keyed = membersOf(part);
+                        if (keyed === UNANSWERED) {
+                            found.push({ kind: "held", from: one.from, names: spelled(one.protocols) });
+                            continue;
+                        }
+                        for (const member of keyed) {
+                            if (!one.protocols.includes(member.name)) {
+                                continue;
+                            }
+                            for (const to of member.ids) {
+                                found.push({
+                                    kind: "named",
+                                    from: one.from,
+                                    to,
+                                    file: one.file,
+                                    at: one.operand,
+                                    use: "read",
+                                    via: "keyed",
+                                });
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};

package/dist/src/tests/file-class.js

@@ -0,0 +1,76 @@
+/**
+ * The file classes the run counts references by. A test file is one a `ts.test_files`
+ * pattern or a test runner's row names (the test-runner entry source decides which), a test
+ * file no project holds, or a consumer's file a pattern names below the consumer's root.
+ * A test-support file is test code as well, decided once the references are known
+ * (`support.ts`), so a reference carries only whether a test file made it and the counters
+ * read the support class beside it.
+ */
+import { renderPosition } from "../position.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+/** The test files of the target: each file the test-runner source names, by its file name. */
+export function targetTestFile(named) {
+    return (file) => named.has(file.fileName);
+}
+/** The test files a pattern names, each by its path below `root`: a consumer's, below the consumer's root. */
+export function patternTestFile(patterns, root) {
+    const expressions = patterns.map(globExpression);
+    return (file) => {
+        const path = renderPosition(file, root, 0).path;
+        return expressions.some((expression) => expression.test(path));
+    };
+}
+/** The own files of a project that are test files, by their path below `root`, ascending. */
+export function testFilePaths(project, root, testFile) {
+    return project
+        .ownSourceFiles()
+        .filter(testFile)
+        .map((file) => renderPosition(file, root, 0).path)
+        .sort(bytewise);
+}
+/** Whether test code made one reference: a test file, or a test-support file of the target. */
+export function madeByTestCode(reference, support) {
+    return (reference.test || (reference.consumer === undefined && support.has(reference.position.path)));
+}
+/** Whether the mode classes a reference test code made as a test one: any but a loaded consumer's it classes as production. */
+export function classedAsTest(test, consumer, mode) {
+    return test && !(consumer && mode.consumerTestsProduction === true);
+}
+/** Whether a production mode counts no reference of this one: test code made it, as the mode classes it. */
+export function withheldBy(mode, reference, support) {
+    return (mode.production &&
+        classedAsTest(madeByTestCode(reference, support), reference.consumer !== undefined, mode));
+}
+/** Whether a production mode follows no edge like this one: {@link withheldBy} for a graph edge. */
+export function edgeWithheldBy(mode, edge) {
+    return mode.production && classedAsTest(edge.test, edge.consumer, mode);
+}
+/** The rule a file the analysis classified as test-support code is counted under. */
+const TEST_SUPPORT_RULE = "test-support";
+/**
+ * The name one test-file rule takes. A rule's name is a word list the report's own
+ * vocabulary spells, which cannot carry a pattern, so a rule is named by the place of
+ * its pattern in the configured list.
+ */
+function patternRule(index) {
+    return `test-file-pattern-${String(index + 1)}`;
+}
+/**
+ * The rules over the test files of several projects at once, ordered by rule: a file two
+ * projects hold is one file, so each rule counts the distinct paths it matches.
+ */
+export function testFileRulesOf(testFiles, paths, supportFiles = []) {
+    const distinct = [...new Set(paths)];
+    const support = new Set(supportFiles).size;
+    return [
+        ...testFiles.map((pattern, index) => {
+            const expression = globExpression(pattern);
+            return {
+                rule: patternRule(index),
+                matched: distinct.filter((path) => expression.test(path)).length,
+            };
+        }),
+        ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
+    ].sort((a, b) => bytewise(a.rule, b.rule));
+}

package/dist/src/{outside-tests.js → tests/outside.js}

@@ -7,15 +7,15 @@
  * it names is not known.
  */
 import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { RESOLVED_EXTENSIONS } from "./entries/configuration-files.js";
-import { emittedFrom } from "./load/emit-map.js";
-import { namesImported } from "./module-declarations.js";
-import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
-import { renderPosition } from "./position.js";
-import { nameComponent } from "./ref.js";
+import { RESOLVED_EXTENSIONS } from "../entries/configuration-files.js";
+import { emittedFrom } from "../load/emit-map.js";
+import { namesImported } from "../import-bindings.js";
+import { dirnamePath, joinPath, normalizePath, queriedModulePath, startsRelativePath, } from "../paths.js";
+import { renderPosition } from "../position.js";
+import { nameComponent } from "../ref.js";
 /** The paths below the target root one relative specifier may name, written path first. */
 function candidates(dir, specifier) {
-    if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+    if (!startsRelativePath(specifier)) {
         return [];
     }
     const path = normalizePath(dir === "" ? specifier : `${dir}/${specifier}`);

package/dist/src/{test-support.js → tests/support.js}

@@ -5,8 +5,8 @@
  * another such file, so it is judged with the tests: what it references is referenced by
  * test code.
  */
-import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./entries/convention-rows.js";
-import { packageOfSpecifier } from "./dependencies.js";
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES, } from "../entries/convention-rows.js";
+import { packageOfSpecifier } from "../dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 /**
@@ -163,12 +163,3 @@ export function testSupportFiles(symbols, references, roots, testFiles, evidence
     const support = withoutOutsideUsers(new Set([...onlyTests].filter((path) => carries(onlyTests, path))));
     return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
-/** 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);
-}