@cplieger/deadset-ts 5.0.0 → 5.1.1

package/dist/src/contextual-uses.js

@@ -0,0 +1,247 @@
+/**
+ * The uses contextual types make of the target's members, which no name node resolves to.
+ * An object-literal property writes the member of its name on each constituent of the
+ * literal's contextual type that declares one. A value reaching a position typed by another
+ * object type reads each of its members that type declares, through array elements and
+ * function parameters and results too; a class instance there is the
+ * interface-satisfaction class's evidence instead.
+ */
+import { isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { SignatureKind } from "@typescript/native/unstable/sync";
+import { isAnswered } from "./query.js";
+/** The member kinds a contextual type writes and reads: data members and the members of object types. */
+const MEMBER_KINDS = new Set(["type-member", "class-member"]);
+/** The name one literal property is written under, where the name is literal text. */
+function propertyName(property) {
+    if (!isPropertyAssignment(property) &&
+        !isShorthandPropertyAssignment(property) &&
+        !isMethodDeclaration(property) &&
+        !isGetAccessorDeclaration(property) &&
+        !isSetAccessorDeclaration(property)) {
+        return undefined;
+    }
+    const name = property.name;
+    if (isIdentifier(name) || isStringLiteral(name) || isNumericLiteral(name)) {
+        return { node: name, text: name.text };
+    }
+    if (isComputedPropertyName(name)) {
+        const key = name.expression;
+        if (isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key)) {
+            return { node: name, text: key.text };
+        }
+    }
+    return undefined;
+}
+/**
+ * The contextual uses of one project's literals and values, asked in batches: one
+ * contextual type per literal and per value whose type carries a member of the target,
+ * one type per value, and each distinct type's properties once.
+ */
+export function contextualUses(project, held, chains, literals, flows, cap, properties) {
+    const queries = project.queries;
+    const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+    let batches = 0;
+    let lookups = 0;
+    const batchesOf = (count) => Math.ceil(count / cap);
+    const parts = new Map();
+    /** The object types one type is: itself, or its constituents at any depth. */
+    const partsOf = (type) => {
+        const known = parts.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        let found = [];
+        if (type.isUnionType() || type.isIntersectionType()) {
+            lookups += 1;
+            const constituents = queries.constituents(type);
+            found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
+        }
+        else if (type.isObjectType()) {
+            found = [type];
+        }
+        parts.set(type.id, found);
+        return found;
+    };
+    const tables = new Map();
+    /** The members one object type has, by name. */
+    const membersOf = (type) => {
+        const known = tables.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const table = new Map();
+        const read = properties.of(type);
+        lookups += read.asked ? 1 : 0;
+        for (const property of isAnswered(read.properties) ? read.properties : []) {
+            table.set(property.name, {
+                ids: chains
+                    .declarationsOf(property)
+                    .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
+                handles: new Set(property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`)),
+            });
+        }
+        tables.set(type.id, table);
+        return table;
+    };
+    const writes = [];
+    batches += batchesOf(literals.length);
+    const contexts = queries.contextualTypes(literals.map((one) => one.literal), cap);
+    literals.forEach(({ literal, from }, index) => {
+        const context = contexts[index];
+        if (context === undefined || !isAnswered(context)) {
+            return;
+        }
+        const tablesOf = partsOf(context).map(membersOf);
+        for (const property of literal.properties) {
+            const name = propertyName(property);
+            if (name === undefined) {
+                continue;
+            }
+            const ids = [...new Set(tablesOf.flatMap((table) => table.get(name.text)?.ids ?? []))];
+            if (ids.length > 0) {
+                writes.push({ at: name.node, from, ids });
+            }
+        }
+    });
+    const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
+    batches += batchesOf(carried.length);
+    const types = queries.typesAt(carried.map((flow) => flow.value), cap);
+    /** The members a position may read structurally: those of object types, not of classes. */
+    const readable = (member) => member.ids.filter((id) => kinds.get(id) === "type-member");
+    const carries = (part) => [...membersOf(part).values()].some((member) => readable(member).length > 0);
+    const elements = new Map();
+    /** The element type of an array type, read once per type. */
+    const elementOf = (type) => {
+        if (elements.has(type.id)) {
+            return elements.get(type.id);
+        }
+        lookups += 1;
+        const isArray = queries.isArray(type);
+        let element;
+        if (isAnswered(isArray) && isArray) {
+            lookups += 1;
+            const held = queries.typeArguments(type);
+            element = isAnswered(held) ? held[0] : undefined;
+        }
+        elements.set(type.id, element);
+        return element;
+    };
+    const calls = new Map();
+    /** The parameter and return types of a type's one call signature, read once per type. */
+    const callOf = (type) => {
+        if (calls.has(type.id)) {
+            return calls.get(type.id);
+        }
+        lookups += 1;
+        const signatures = queries.signaturesOf(type, SignatureKind.Call);
+        let called;
+        const [signature, ...more] = isAnswered(signatures) ? signatures : [];
+        if (signature !== undefined && more.length === 0) {
+            const parameters = signature.parameters.map((_parameter, index) => queries.parameterType(signature, index));
+            const result = queries.returnTypeOf(signature);
+            lookups += parameters.length + 1;
+            called = {
+                parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
+                result: isAnswered(result) ? result : undefined,
+            };
+        }
+        calls.set(type.id, called);
+        return called;
+    };
+    /**
+     * Each object type a value of `source` is checked as against the object types of
+     * `target`: the value's own, and through array elements and through a function's
+     * parameters, checked the other way, and its result. A source that is one of the
+     * target's own object types matches it as it stands. Each pair is compared once, which
+     * ends the walk over a recursive type.
+     */
+    const compared = (source, target, into, seen) => {
+        const key = `${String(source?.id)}>${String(target?.id)}`;
+        if (source === undefined || target === undefined || source.id === target.id) {
+            return;
+        }
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        const targets = partsOf(target);
+        const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
+        for (const one of sources) {
+            if (carries(one)) {
+                into.push({ source: one, targets });
+            }
+            const element = elementOf(one);
+            const called = element === undefined ? callOf(one) : undefined;
+            for (const part of targets) {
+                if (element !== undefined) {
+                    compared(element, elementOf(part), into, seen);
+                    continue;
+                }
+                const other = called === undefined ? undefined : callOf(part);
+                if (called === undefined || other === undefined) {
+                    continue;
+                }
+                other.parameters.forEach((parameter, index) => {
+                    compared(parameter, called.parameters[index], into, seen);
+                });
+                compared(called.result, other.result, into, seen);
+            }
+        }
+    };
+    /**
+     * Whether a value of one type may carry a member a position reads, at any depth the
+     * walk takes. A type met again on the way adds nothing its first visit did not.
+     */
+    const mayCarry = (type, seen = new Set()) => {
+        if (seen.has(type.id)) {
+            return false;
+        }
+        seen.add(type.id);
+        return partsOf(type).some((part) => {
+            if (carries(part)) {
+                return true;
+            }
+            const element = elementOf(part);
+            if (element !== undefined) {
+                return mayCarry(element, seen);
+            }
+            return callOf(part) !== undefined;
+        });
+    };
+    const sourced = carried.flatMap((flow, index) => {
+        const type = types[index];
+        return type === undefined || !isAnswered(type) || !mayCarry(type) ? [] : [{ flow, type }];
+    });
+    batches += batchesOf(sourced.length);
+    const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
+    const reads = [];
+    sourced.forEach(({ flow, type }, index) => {
+        const position = positions[index];
+        if (position === undefined || !isAnswered(position)) {
+            return;
+        }
+        const checked = [];
+        compared(type, position, checked, new Set());
+        const ids = new Set();
+        for (const { source, targets } of checked) {
+            const tables = targets.map(membersOf);
+            for (const [name, member] of membersOf(source)) {
+                const read = tables.some((table) => {
+                    const declared = table.get(name);
+                    return (declared !== undefined &&
+                        declared.handles.size > 0 &&
+                        ![...declared.handles].some((handle) => member.handles.has(handle)));
+                });
+                if (read) {
+                    for (const id of readable(member)) {
+                        ids.add(id);
+                    }
+                }
+            }
+        }
+        if (ids.size > 0) {
+            reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
+        }
+    });
+    return { writes, reads, batches, lookups };
+}

package/dist/src/convention-rows.js

@@ -45,6 +45,7 @@ export const CONVENTION_ROWS = [
             `<src>/content/config.${MODULE}`,
         ],
         excludes: ["<src>/pages/**/_*", "<src>/pages/**/_*/**"],
+        generated: [".astro"],
         moves: [
             {
                 id: "src",
@@ -71,6 +72,7 @@ export const CONVENTION_ROWS = [
         name: "next",
         package: "next",
         range: ">=13.4.0 <17.0.0",
+        generated: [".next"],
         entries: [
             `{,src/}app/**/{layout,page,loading,not-found,error,route,template,default,forbidden,unauthorized}.${SCRIPT}`,
             `{,src/}app/global-{error,not-found}.${SCRIPT}`,
@@ -87,6 +89,7 @@ export const CONVENTION_ROWS = [
         name: "nuxt",
         package: "nuxt",
         range: ">=3.0.0 <5.0.0",
+        generated: [".nuxt"],
         entries: [
             "<srcDir>/{app,error}.{vue,jsx,tsx}",
             `<srcDir>/app.config.${MODULE}`,
@@ -181,6 +184,7 @@ export const CONVENTION_ROWS = [
         package: "@react-router/dev",
         range: ">=7.0.0 <9.0.0",
         entries: APP_DIRECTORY_ENTRIES,
+        generated: [".react-router"],
         moves: [
             {
                 id: "app",
@@ -259,6 +263,7 @@ export const CONVENTION_ROWS = [
         package: "@sveltejs/kit",
         range: ">=2.0.0 <3.0.0",
         entries: [...SVELTEKIT_ENTRIES, "<params>/*.{js,ts}"],
+        generated: [".svelte-kit"],
         moves: [
             {
                 id: "src",
@@ -323,6 +328,7 @@ export const CONVENTION_ROWS = [
         package: "@sveltejs/kit",
         range: ">=3.0.0 <4.0.0",
         entries: [...SVELTEKIT_ENTRIES, "<params>.{js,ts}"],
+        generated: [".svelte-kit"],
         moves: [
             {
                 id: "src",

package/dist/src/conventions.js

@@ -5,15 +5,16 @@
  * directory a configuration property moves read from the property's literal value.
  * No configuration file is run.
  */
-import { isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { lineOf } from "./component-files.js";
 import { CONVENTION_ROWS, } from "./convention-rows.js";
 import { globExpression } from "./glob.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
+/** The sections an installed package is required by, so its absence fails the run. */
+const REQUIRED_SECTIONS = ["dependencies", "devDependencies"];
 const DEPENDENCY_SECTIONS = [
-    "dependencies",
-    "devDependencies",
+    ...REQUIRED_SECTIONS,
     "peerDependencies",
     "optionalDependencies",
 ];
@@ -28,11 +29,11 @@ function readJSON(host, path) {
         return undefined;
     }
 }
-function declares(manifest, name) {
+function declares(manifest, name, sections = DEPENDENCY_SECTIONS) {
     if (!isRecord(manifest)) {
         return false;
     }
-    return DEPENDENCY_SECTIONS.some((section) => {
+    return sections.some((section) => {
         const held = manifest[section];
         return isRecord(held) && Object.hasOwn(held, name);
     });
@@ -70,20 +71,29 @@ function unwrapped(node) {
     }
     return at;
 }
-/** The key one property is written with, where it is written as a name or a literal. */
+/** The key one property is written with, where it is written as a name or as literal text. */
 function keyOf(property) {
     if (!isPropertyAssignment(property) && !isShorthandPropertyAssignment(property)) {
         return undefined;
     }
     const { name } = property;
-    if (isComputedPropertyName(name)) {
-        return undefined;
-    }
-    if (isIdentifier(name) || isStringLiteral(name) || isNoSubstitutionTemplateLiteral(name)) {
-        return name.text;
+    const key = isComputedPropertyName(name) ? name.expression : name;
+    if ((isIdentifier(key) && key === name) ||
+        isStringLiteral(key) ||
+        isNoSubstitutionTemplateLiteral(key)) {
+        return key.text;
     }
     return undefined;
 }
+/** Whether one member's computed name is no literal, so it may set any key. */
+function computesKey(member) {
+    const name = member.name;
+    if (name === undefined || !isComputedPropertyName(name)) {
+        return false;
+    }
+    const key = name.expression;
+    return !(isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key));
+}
 /** The values one file's top-level variable declarations bind, by name. */
 function declaredValues(file) {
     const values = new Map();
@@ -134,6 +144,67 @@ function defaultExports(file) {
     }
     return found;
 }
+/** The declarations whose name is a binding of the scope they are written in. */
+const BINDING_KINDS = new Set([
+    SyntaxKind.VariableDeclaration,
+    SyntaxKind.Parameter,
+    SyntaxKind.BindingElement,
+    SyntaxKind.FunctionDeclaration,
+    SyntaxKind.ClassDeclaration,
+    SyntaxKind.ImportClause,
+    SyntaxKind.ImportSpecifier,
+    SyntaxKind.NamespaceImport,
+    SyntaxKind.ImportEqualsDeclaration,
+]);
+/** Whether one file declares a binding named `require` at any depth, which shadows the global. */
+function declaresRequire(file) {
+    let found = false;
+    const visit = (node) => {
+        const name = node.name;
+        if (name !== undefined &&
+            isIdentifier(name) &&
+            name.text === "require" &&
+            BINDING_KINDS.has(node.kind)) {
+            found = true;
+        }
+        if (!found) {
+            node.forEachChild(visit);
+        }
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * The top-level `const`, `let` and `var` declarations that bind a `require` of one module,
+ * written with the module's name as its one string-literal argument, in a file that
+ * declares no binding named `require`: each binds as an import of the module does.
+ */
+function requireBindings(file, module) {
+    const found = [];
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const value = declaration.initializer === undefined ? undefined : unwrapped(declaration.initializer);
+            const [argument, ...rest] = value !== undefined && isCallExpression(value) ? value.arguments : [];
+            if (value === undefined ||
+                !isCallExpression(value) ||
+                !isIdentifier(value.expression) ||
+                value.expression.text !== "require" ||
+                argument === undefined ||
+                rest.length > 0 ||
+                !isStringLiteral(argument) ||
+                argument.text !== module) {
+                continue;
+            }
+            if (isIdentifier(declaration.name) || isObjectBindingPattern(declaration.name)) {
+                found.push(declaration.name);
+            }
+        }
+    }
+    return found.length > 0 && declaresRequire(file) ? [] : found;
+}
 /**
  * The first argument of every call one file makes to one module's export, through a
  * named or a namespace import; `undefined` for a call with no argument.
@@ -141,6 +212,24 @@ function defaultExports(file) {
 function optionsArguments(file, call) {
     const names = new Set();
     const namespaces = new Set();
+    for (const name of requireBindings(file, call.module)) {
+        if (isIdentifier(name)) {
+            namespaces.add(name.text);
+            continue;
+        }
+        for (const element of name.elements) {
+            const local = element.name;
+            const exported = element.propertyName ?? local;
+            if (element.dotDotDotToken === undefined &&
+                local !== undefined &&
+                isIdentifier(local) &&
+                exported !== undefined &&
+                (isIdentifier(exported) || isStringLiteral(exported)) &&
+                exported.text === call.export) {
+                names.add(local.text);
+            }
+        }
+    }
     for (const statement of file.statements) {
         const bindings = isImportDeclaration(statement)
             ? statement.importClause?.namedBindings
@@ -207,7 +296,7 @@ function objectOf(node, declared, throughCalls, seen = new Set()) {
 function readPath(object, keys, values) {
     const [key, ...rest] = keys;
     for (const member of object.properties) {
-        if (isSpreadAssignment(member)) {
+        if (isSpreadAssignment(member) || computesKey(member)) {
             return member;
         }
         if (keyOf(member) !== key) {
@@ -352,6 +441,7 @@ function compare(a, b) {
 export function readConventions(host, parse, manifests, disabled, rows = CONVENTION_ROWS) {
     const applied = [];
     const globs = [];
+    const generated = [];
     const failures = [];
     for (const manifest of manifests) {
         const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
@@ -366,7 +456,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             }
             const version = versions.get(row.package);
             if (version === undefined) {
-                if (missing.has(row.package)) {
+                if (missing.has(row.package) || !declares(declared, row.package, REQUIRED_SECTIONS)) {
                     continue;
                 }
                 missing.add(row.package);
@@ -413,6 +503,9 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             const excludes = [
                 ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
             ].map(globExpression);
+            for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
+                generated.push({ dir: manifest.dir, row: row.name, below });
+            }
             for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
                 globs.push({
                     dir: manifest.dir,
@@ -427,7 +520,23 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     unique.sort((a, b) => compare(a.name, b.name) ||
         compare(a.manifest, b.manifest) ||
         compare(JSON.stringify(a), JSON.stringify(b)));
-    return { applied: unique, globs, failures };
+    return { applied: unique, globs, generated, failures };
+}
+/**
+ * Every own file of one project below a directory an applied row names as generated, by
+ * its path below the target root, with the name of the first such row.
+ */
+export function generatedFiles(conventions, files) {
+    const found = new Map();
+    for (const { dir, row, below } of conventions.generated) {
+        const root = joinPath(dir, below);
+        for (const [path, file] of files.byPath) {
+            if (!found.has(path) && relativePath(root, file.fileName) !== undefined) {
+                found.set(path, row);
+            }
+        }
+    }
+    return found;
 }
 /** Every own file of one project an applied row's globs match, once per row. */
 export function conventionEntries(conventions, files) {

package/dist/src/dependencies.js

@@ -187,7 +187,7 @@ function bindingsOf(node) {
  * shadows the name is not one. A string of a configuration file uses each dependency
  * the manifest beside the file declares that it spells.
  */
-export function projectNeeds(project, held, host, targetRoot) {
+export function projectNeeds(project, held, host, targetRoot, parse) {
     const programPackages = new Set();
     for (const name of project.program.getSourceFileNames()) {
         const named = packageOfPath(name);
@@ -225,7 +225,7 @@ export function projectNeeds(project, held, host, targetRoot) {
         }
         return names;
     };
-    const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot));
+    const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot), parse);
     for (const { file } of configuration.modules) {
         const names = declaredAt(file.fileName);
         for (const { node, text } of moduleStrings(file)) {
@@ -238,6 +238,12 @@ export function projectNeeds(project, held, host, targetRoot) {
             use([PROJECT_OWNER], dependenciesNamed(text, names));
         }
     }
+    for (const { file, manifestDir } of configuration.outside) {
+        const names = declaredAt(joinPath(manifestDir, "package.json"));
+        for (const { text } of moduleStrings(file)) {
+            use([PROJECT_OWNER], dependenciesNamed(text, names));
+        }
+    }
     return { packages, uses, unanswered };
 }
 /** The declarations of the inventory a use written at one node belongs to. */

package/dist/src/destructuring.js

@@ -7,7 +7,7 @@
  */
 import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { TypeFlags } from "@typescript/native/unstable/sync";
-import { isAnswered, UNANSWERED } from "./query.js";
+import { isAnswered, propertyTables, UNANSWERED, } from "./query.js";
 /** The text a property name spells, or `undefined` for a computed name. */
 function nameText(node) {
     if (node === undefined) {
@@ -151,7 +151,7 @@ function sourceOf(target) {
  * read once per type for the whole project, since one type is destructured in many
  * places and a table answers every name of it.
  */
-export function destructuring(project, cap) {
+export function destructuring(project, cap, properties = propertyTables(project.queries)) {
     const queries = project.queries;
     const tables = new Map();
     let patternBatches = 0;
@@ -163,10 +163,10 @@ export function destructuring(project, cap) {
         }
         let table = new Map();
         if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
-            patternLookups += 1;
-            const properties = queries.propertiesOf(type);
-            table = isAnswered(properties)
-                ? new Map(properties.map((property) => [property.name, property]))
+            const read = properties.of(type);
+            patternLookups += read.asked ? 1 : 0;
+            table = isAnswered(read.properties)
+                ? new Map(read.properties.map((property) => [property.name, property]))
                 : UNANSWERED;
         }
         tables.set(type.id, table);

package/dist/src/entry-points.js

@@ -12,7 +12,7 @@
  */
 import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
-import { configurationFiles, filesNamedBy, moduleStrings } from "./configuration-files.js";
+import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
@@ -169,8 +169,8 @@ function isBrowserTestConfig(name) {
  * with what it exports, and each own file a relative string of a configuration module
  * or a JSON configuration file names, read against that file's directory.
  */
-function configurationEntries(host, targetRoot, files) {
-    const { modules, documents } = configurationFiles(host, targetRoot, files);
+function configurationEntries(host, targetRoot, files, parse) {
+    const { modules, documents, outside } = configurationFiles(host, targetRoot, files, parse);
     const found = [];
     const strings = (dir, texts) => {
         for (const text of texts) {
@@ -186,6 +186,9 @@ function configurationEntries(host, targetRoot, files) {
     for (const document of documents) {
         strings(dirnamePath(document.path), document.strings);
     }
+    for (const { file } of outside) {
+        strings(dirnamePath(file.fileName), moduleStrings(file).map((one) => one.text));
+    }
     return found;
 }
 /**
@@ -381,8 +384,8 @@ function workersOf(project, file, files) {
  * file's path below the target root; a file one of them matches is a test file the
  * runner executes.
  */
-export function entryPoints(project, files, testFiles, host, targetRoot) {
-    const found = [...configurationEntries(host, targetRoot, files)];
+export function entryPoints(project, files, testFiles, host, targetRoot, parse) {
+    const found = [...configurationEntries(host, targetRoot, files, parse)];
     const tests = testFiles.map((pattern) => ({ pattern, expression: globExpression(pattern) }));
     for (const [path, file] of files.byPath) {
         const name = basename(path);

package/dist/src/exempt-classes.js

@@ -26,7 +26,12 @@ export const EXEMPTION_CLASSES = [
         confidence: "certain",
         typescriptVisibility: { private: false, privateName: false },
     },
-    { class: "generated-file", languages: ["go"], confidence: "certain" },
+    {
+        class: "generated-file",
+        languages: ["go", "ts"],
+        confidence: "certain",
+        typescriptVisibility: { private: true, privateName: false },
+    },
     { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
     {
         class: "template-field",