@cplieger/deadset-ts 7.2.0-dev.3 → 7.2.0-dev.4

package/dist/src/discover.js

@@ -1,5 +1,5 @@
 import { DiagnosticCategory } from "@typescript/native/sync";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { SetupError } from "./setup-failure.js";
 /** Directory names discovery does not descend into. */
 export const IGNORED_DIRECTORIES = new Set(["node_modules", ".git"]);
@@ -60,12 +60,28 @@ 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
+ */
+const UNFOUND_LIBRARY = new Set([2688, 2726, 2727]);
 /** 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 +102,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 +137,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 +150,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 +168,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 +202,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 +215,48 @@ 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) {
+/**
+ * The configuration files one configuration's `references` name, or why the compiler
+ * cannot read the configuration.
+ */
+function readConfiguration(engine, configFile) {
     try {
-        engine.parseConfigFile(configFile);
-        return undefined;
+        const parsed = engine.parseConfigFile(configFile);
+        // 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 {
+            references: (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json")),
+        };
     }
     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 +270,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 +292,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}`, []);
         }

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/intra-function-parts.js

@@ -4,11 +4,12 @@
  * call sites that use or discard it, each statement control flow cannot reach, each
  * write to a local that no read reaches, and each case an earlier case covers.
  */
-import { isArrayBindingPattern, isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isConstructorDeclaration, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayBindingPattern, isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isConstructorDeclaration, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isSourceFile, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { isParameterProperty, nodeKey } from "./inventory.js";
 import { positionKey, renderPosition } from "./position.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
+import { spellsNoBinding } from "./spelled-names.js";
 /** The codes of the parts this module reads. */
 export const UNUSED_PARAMETER = "DS1801";
 export const UNUSED_RESULT = "DS1803";
@@ -117,13 +118,12 @@ function caseKey(expression) {
     }
     return undefined;
 }
-/** Every identifier below one node whose text one of the names spells, a member's name aside. */
+/** Every identifier below one node whose text one of the names spells as a reference. */
 function identifiersNaming(node, names) {
     const found = [];
     const visit = (at) => {
         if (isIdentifier(at)) {
-            const parent = at.parent;
-            if (names.has(at.text) && !(isPropertyAccessExpression(parent) && parent.name === at)) {
+            if (names.has(at.text) && !spellsNoBinding(at)) {
                 found.push(at);
             }
             return;
@@ -154,6 +154,15 @@ function inNestedFunction(node, outer) {
     }
     return false;
 }
+/** The nearest function around one node whose `arguments` object it names: an arrow has none. */
+function ownArgumentsOf(node) {
+    for (let at = node.parent; !isSourceFile(at); at = at.parent) {
+        if (isFunctionLikeDeclaration(at) && !isArrowFunction(at)) {
+            return at;
+        }
+    }
+    return undefined;
+}
 /** Whether a body is a stub: it holds no statement, or nothing but `throw` statements. */
 function isStub(signature) {
     const body = signature.body;
@@ -608,8 +617,10 @@ function withContextualRead(project, parts, contextual) {
  * as read where its function reads any name it binds.
  */
 function parameterParts(file, root, declaration, signature, reader, ids, inValue) {
-    // A function that reads `arguments` reads every parameter by position.
-    const readsArguments = !isArrowFunction(signature) && identifiersNaming(signature, new Set(["arguments"])).length > 0;
+    // A function that reads its `arguments` reads every parameter by position. A nested
+    // function other than an arrow has an `arguments` object of its own.
+    const readsArguments = !isArrowFunction(signature) &&
+        identifiersNaming(signature, new Set(["arguments"])).some((use) => ownArgumentsOf(use) === signature);
     const read = reader.names.map(({ name }) => readsArguments ||
         reader.uses.some((use) => use.text === name.text && readsBinding(use, name, ids)));
     const lastRead = Math.max(-1, ...reader.names.filter((_, at) => read[at]).map((one) => one.at));

package/dist/src/inventory.js

@@ -204,6 +204,17 @@ function visibilityOf(node, name) {
 function nameNodeOf(node) {
     return node.name;
 }
+/**
+ * The fragment component one declaration's name spells in a reference, as the inventory
+ * spells it, or undefined for a name the grammar does not represent.
+ */
+export function declaredComponent(node) {
+    const component = componentOf(nameNodeOf(node));
+    if (component === undefined) {
+        return undefined;
+    }
+    return component.computed ? computedComponent(component.text) : nameComponent(component.text);
+}
 /**
  * One node's identity inside one program, which is how two readings of that program
  * name one declaration.

package/dist/src/json-document.js

@@ -4,7 +4,7 @@
  */
 /** The token walk over a document `JSON.parse` accepted, so every token is well formed. */
 class Walk {
-    opened = [];
+    starts = [];
     /** The member written twice, where one is, as the offset of its name. */
     twice;
     text;
@@ -33,11 +33,11 @@ class Walk {
     }
     value(role) {
         this.skip();
+        if (role === "record") {
+            this.starts.push(this.at);
+        }
         const char = this.text[this.at];
         if (char === "{") {
-            if (role === "record") {
-                this.opened.push(this.at);
-            }
             this.object(role);
         }
         else if (char === "[") {
@@ -100,7 +100,7 @@ class Walk {
 export function walkDocument(text, array) {
     const walk = new Walk(text, array);
     walk.run();
-    return { opened: walk.opened, twice: walk.twice };
+    return { starts: walk.starts, twice: walk.twice };
 }
 /**
  * One offset of a document as a finding carries it: the line counted from one, and the

package/dist/src/namespace-objects.js

@@ -1,11 +1,12 @@
 /**
  * Module namespace objects: the binding of a namespace import, the value an `await` of a
  * dynamic `import()` produces, the first parameter of the first callback passed to `then`
- * on one, and a `const` binding initialized with one of these. A use reads the exports it
+ * on one, and a variable binding initialized with one of these. A use reads the exports it
  * names and no other: a property access by name or by a literal index, or a destructured
  * property, names one export, and any other use may read every export.
  */
-import { isArrowFunction, isAwaitExpression, isBindingElement, isCallExpression, isElementAccessExpression, isExpressionStatement, isFunctionExpression, isIdentifier, isImportDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isParenthesizedExpression, isPropertyAccessExpression, isQualifiedName, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { isArrowFunction, isAwaitExpression, isCallExpression, isClassStaticBlockDeclaration, isElementAccessExpression, isExpressionStatement, isFunctionExpression, isFunctionLikeDeclaration, isIdentifier, isImportDeclaration, isModuleBlock, isNamespaceImport, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isParenthesizedExpression, isPropertyAccessExpression, isQualifiedName, isSourceFile, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { spellsNoBinding } from "./spelled-names.js";
 function isLiteralText(node) {
     return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
 }
@@ -25,21 +26,30 @@ function isLiteralImport(node) {
     const [argument] = node.arguments;
     return argument !== undefined && isLiteralText(argument);
 }
-/** The node a `const` binding's name is visible below: the block or file its statement is in. */
-function scopeOf(declaration) {
-    const statement = declaration.parent.parent;
-    return statement.parent;
+/**
+ * The node the binding one declaration list declares is visible below: for `let` and
+ * `const`, the loop whose head declares it, or else the block or file its statement is
+ * in; for `var`, the function, namespace body, static block or file that holds it.
+ */
+function scopeOf(list) {
+    if ((list.flags & (NodeFlags.Let | NodeFlags.Const | NodeFlags.Using)) !== 0) {
+        return isVariableStatement(list.parent) ? list.parent.parent : list.parent;
+    }
+    let at = list.parent;
+    while (!isSourceFile(at) &&
+        !isFunctionLikeDeclaration(at) &&
+        !isModuleBlock(at) &&
+        !isClassStaticBlockDeclaration(at)) {
+        at = at.parent;
+    }
+    return at;
 }
-/** Every identifier below `scope` that spells `name`, other than `declared` and a member's name. */
+/** Every identifier below `scope` that spells `name` as a reference, other than `declared`. */
 function occurrences(scope, name, declared) {
     const found = [];
     const visit = (node) => {
         if (isIdentifier(node)) {
-            const parent = node.parent;
-            const member = (isPropertyAccessExpression(parent) && parent.name === node) ||
-                (isQualifiedName(parent) && parent.right === node) ||
-                (isBindingElement(parent) && parent.propertyName === node);
-            if (node !== declared && node.text === name && !member) {
+            if (node !== declared && node.text === name && !spellsNoBinding(node)) {
                 found.push(node);
             }
             return;
@@ -52,8 +62,8 @@ function occurrences(scope, name, declared) {
 /**
  * Every use of the namespace objects one file holds, keyed by the node the use is written
  * at, that reads more than a name the checker resolves: an indexed read by a literal, and
- * any use that may read every export. A shadowing declaration of a binding's name inside
- * its scope is read as the binding, which can only keep an export live.
+ * any use that may read every export. A use of a shadowing declaration of a binding's
+ * name inside its scope is read as a use of the binding, which can only keep an export live.
  */
 export function namespaceUses(file) {
     const uses = new Map();
@@ -92,11 +102,11 @@ export function namespaceUses(file) {
                 }
                 return;
             }
+            // A binding that is not `const` is followed too: each assignment to it is an
+            // occurrence `value` cannot narrow, so a reassigned binding still reads every export.
             const list = parent.parent;
-            if (isIdentifier(pattern) &&
-                isVariableDeclarationList(list) &&
-                (list.flags & NodeFlags.Const) !== 0) {
-                binding(pattern, scopeOf(parent), specifier, seen);
+            if (isIdentifier(pattern) && isVariableDeclarationList(list)) {
+                binding(pattern, scopeOf(list), specifier, seen);
                 return;
             }
         }

package/dist/src/overrides.js

@@ -12,6 +12,10 @@ import { nodeKey } from "./inventory.js";
 import { SymbolFlags } from "@typescript/native/sync";
 import { UNANSWERED } from "./query.js";
 import { nameComponent } from "./ref.js";
+const CLASS_DECLARATIONS = new Set([
+    SyntaxKind.ClassDeclaration,
+    SyntaxKind.ClassExpression,
+]);
 /** The member kinds a subclass overrides. */
 const OVERRIDABLE = new Set(["method", "class-member"]);
 /** The node naming the class one `extends` entry names. */
@@ -82,8 +86,9 @@ export function overrideReferences(project, held, chains, testFiles) {
             if (inTarget.length === 0 &&
                 declared !== UNANSWERED &&
                 (declared.flags & SymbolFlags.Class) !== 0 &&
-                declared.declarations.length > 0 &&
-                declared.declarations.every((handle) => !own.has(handle.path))) {
+                // The target's augmentation of an outside class merges an interface into it,
+                // so only a class declaration says where the class is.
+                declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) {
                 outsideBases.set(id, declared);
             }
         }

package/dist/src/paths.js

@@ -61,6 +61,15 @@ export function dirnamePath(path) {
     }
     return cut === 0 ? SEPARATOR : normalized.slice(0, cut);
 }
+/**
+ * The extension of one path's last segment, from its last full stop, or the empty string
+ * where it has none. A segment that only starts with a full stop has none.
+ */
+export function extensionOf(path) {
+    const name = path.slice(path.lastIndexOf(SEPARATOR) + 1);
+    const dot = name.lastIndexOf(".");
+    return dot <= 0 ? "" : name.slice(dot);
+}
 /** One path resolved against a directory, absolute where that directory is. */
 export function resolvePath(against, path) {
     return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);

package/dist/src/references.js

@@ -661,19 +661,29 @@ export function references(project, held, targetRoot, options) {
             relativePath(targetRoot, file.fileName) === undefined);
     const ownPaths = project.ownPaths();
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
-    let topLevel;
-    /** The declarations one file's top level holds. */
-    const declaredIn = (fileId) => {
-        if (topLevel === undefined) {
-            const byParent = new Map();
+    let moduleBodies;
+    /**
+     * The declarations one module holds directly: a file's top level, or the body of a
+     * `declare module` whose name is a string. Any other declaration holds none here.
+     */
+    const declaredIn = (moduleId) => {
+        if (moduleBodies === undefined) {
+            const byModule = new Map();
             for (const symbol of held.symbols) {
-                if (fileIds.has(symbol.parent)) {
-                    byParent.set(symbol.parent, [...(byParent.get(symbol.parent) ?? []), symbol]);
+                if (!fileIds.has(symbol.parent) && !held.modules.has(symbol.parent)) {
+                    continue;
+                }
+                const siblings = byModule.get(symbol.parent);
+                if (siblings === undefined) {
+                    byModule.set(symbol.parent, [symbol]);
+                }
+                else {
+                    siblings.push(symbol);
                 }
             }
-            topLevel = byParent;
+            moduleBodies = byModule;
         }
-        return topLevel.get(fileId) ?? [];
+        return moduleBodies.get(moduleId) ?? [];
     };
     const exportsCache = new Map();
     /**
@@ -975,8 +985,11 @@ export function references(project, held, targetRoot, options) {
         }
         for (const url of urls) {
             const constructor = url.constructor === undefined ? undefined : answered.get(url.constructor);
+            // An augmentation of the global `URL` merges into it, which keeps the
+            // library's declaration; a `URL` the target declares has no other.
             if (typeof constructor === "object" &&
-                constructor.declarations.some((handle) => ownPaths.has(handle.path))) {
+                constructor.declarations.length > 0 &&
+                constructor.declarations.every((handle) => ownPaths.has(handle.path))) {
                 continue;
             }
             const loaded = specifierCandidates(dirnamePath(file.fileName), url.specifier)
@@ -1133,14 +1146,14 @@ export function references(project, held, targetRoot, options) {
     }
     let typedLookups = 0;
     if (consumer === undefined) {
-        found.push(...overrideReferences(project, held, chains, new Set(tests)));
         const before = options.requestCount?.() ?? 0;
+        found.push(...overrideReferences(project, held, chains, new Set(tests)));
         found.push(...indexedAccessReferences(project, held, chains, root, new Set(tests)));
         found.push(...elementAccessReferences(project, held, chains, root, new Set(tests)));
         found.push(...keyofComparisonReferences(project, held, chains, root, new Set(tests)));
         found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
-        typedLookups = (options.requestCount?.() ?? 0) - before;
         found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
+        typedLookups = (options.requestCount?.() ?? 0) - before;
     }
     const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
     found.push(...augmentationReferences(held, found, scripts));

package/dist/src/reflective-lookup.js

@@ -90,8 +90,9 @@ export function reflectiveLookup(input) {
     if (lookups.length === 0) {
         return [];
     }
-    // Whether each written `Reflect` is the global one, asked in one batch: a
-    // declaration of that name in one of the project's own files shadows it.
+    // Whether each written `Reflect` is the global one, asked in one batch: a name
+    // declared only in the project's own files shadows it, and an augmentation of the
+    // global merges into it, which keeps the library's declaration.
     const ownFiles = project.ownPaths();
     const reflects = lookups.flatMap((lookup) => lookup.reflect === undefined ? [] : [lookup.reflect]);
     const global = new Set();
@@ -99,10 +100,11 @@ export function reflectiveLookup(input) {
         project.symbolsAt(reflects.map((node) => project.handle(node))).forEach((symbol, index) => {
             const node = reflects[index];
             // A name the checker did not answer for is read as the global, which retains.
-            const declaredHere = symbol === UNANSWERED
-                ? false
-                : symbol?.declarations.some((declaration) => ownFiles.has(declaration.path));
-            if (node !== undefined && declaredHere === false) {
+            const isGlobal = symbol === UNANSWERED ||
+                (symbol !== undefined &&
+                    (symbol.declarations.length === 0 ||
+                        symbol.declarations.some((declaration) => !ownFiles.has(declaration.path))));
+            if (node !== undefined && isGlobal) {
                 global.add(node);
             }
         });