@cplieger/deadset-ts 8.0.0-dev.14 → 8.0.0-dev.15

package/dist/src/load/discover.js

@@ -1,6 +1,6 @@
 import { LANGUAGE_ROWS } from "../contract/contract.generated.js";
 import { filesBelow, filesIn } from "../fs/tree.js";
-import { packageScope } from "../inventory.js";
+import { packageScope } from "./package-scope.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
 import { LANGUAGE, message } from "../product.js";
 import { globExpression } from "../text/glob.js";

package/dist/src/load/package-scope.js

@@ -0,0 +1,56 @@
+import { manifestAt } from "../fs/manifest.js";
+import { dirnamePath, joinPath } from "../paths.js";
+/**
+ * Resolves each file's package scope: the name of the nearest manifest at or above its
+ * directory up to the target root, and the file's path below that manifest. Where no
+ * manifest up to the root carries a name, the package is a single dot and the path is read
+ * from the root, which cannot collide, because a package name never starts with a dot. One
+ * directory is read at most once.
+ */
+export function packageScope(host, root) {
+    const named = new Map();
+    const manifestName = (dir) => {
+        const name = manifestAt(host, joinPath(root, dir))?.["name"];
+        return typeof name === "string" && name !== "" ? name : undefined;
+    };
+    const nearest = (dir) => {
+        if (named.has(dir)) {
+            return named.get(dir);
+        }
+        const name = manifestName(dir);
+        const found = name !== undefined ? { name, at: dir } : dir === "" ? undefined : nearest(parentOf(dir));
+        named.set(dir, found);
+        return found;
+    };
+    return (path) => {
+        const found = nearest(parentOf(path));
+        if (found === undefined) {
+            return { package: ".", path };
+        }
+        return { package: found.name, path: found.at === "" ? path : path.slice(found.at.length + 1) };
+    };
+}
+/**
+ * Whether Node reads each file's `.js` siblings as ECMAScript modules: the `type` of the
+ * nearest manifest at or above its directory up to the target root is `module`
+ * (https://nodejs.org/api/packages.html#type). One directory is read at most once.
+ */
+export function packageTypeIsModule(host, root) {
+    const typed = new Map();
+    const nearest = (dir) => {
+        const known = typed.get(dir);
+        if (known !== undefined) {
+            return known;
+        }
+        const manifest = manifestAt(host, joinPath(root, dir));
+        const found = manifest !== undefined ? manifest["type"] === "module" : dir !== "" && nearest(parentOf(dir));
+        typed.set(dir, found);
+        return found;
+    };
+    return (path) => nearest(parentOf(path));
+}
+/** The directory one path below the root sits in, and the root itself as the empty path. */
+function parentOf(path) {
+    const dir = dirnamePath(path);
+    return dir === "." ? "" : dir;
+}

package/dist/src/own-body.js

@@ -0,0 +1,28 @@
+import { isArrowFunction, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isVariableDeclaration, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { isAmbient } from "./inventory.js";
+import { unwrapped } from "./unwrap.js";
+/**
+ * Whether `symbol`, through its aliases, names a function or class the target writes with a
+ * body, which a call or construction runs in place of the platform's `require` or `URL`. Any
+ * other answer, an unresolved one included, is the platform's, whose call loads a file.
+ */
+export function hasOwnBody(project, symbol) {
+    const named = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
+    const own = project.ownPaths();
+    return (typeof named === "object" &&
+        named.declarations.some((handle) => {
+            const node = own.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+            const value = node !== undefined && isVariableDeclaration(node) && node.initializer !== undefined
+                ? unwrapped(node.initializer)
+                : node;
+            return (value !== undefined &&
+                (isFunctionDeclaration(value)
+                    ? value.body !== undefined
+                    : isFunctionExpression(value) ||
+                        isArrowFunction(value) ||
+                        isClassDeclaration(value) ||
+                        isClassExpression(value)) &&
+                !isAmbient(value.getSourceFile(), value));
+        }));
+}

package/dist/src/position.js

@@ -25,6 +25,47 @@ export function isComponentFile(file) {
 export function writtenLength(file) {
     return isComponentFile(file) ? file.originalText.length : file.text.length;
 }
+/** Whether one character ends a line, under the language's line terminators. */
+function endsLine(char) {
+    return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
+}
+/** The offset where the line holding `from` ends. */
+export function lineEnd(text, from) {
+    let at = from;
+    while (at < text.length && !endsLine(text[at])) {
+        at += 1;
+    }
+    return at;
+}
+/**
+ * The offset of the first token at or after `from`: whitespace, comments and a leading
+ * hashbang are trivia.
+ */
+export function tokenStart(text, from) {
+    let at = from;
+    if (at === 0 && text.startsWith("#!")) {
+        at = lineEnd(text, 0);
+    }
+    for (;;) {
+        if (/\s/u.test(text[at] ?? "")) {
+            at += 1;
+        }
+        else if (text.startsWith("//", at)) {
+            at = lineEnd(text, at);
+        }
+        else if (text.startsWith("/*", at)) {
+            const close = text.indexOf("*/", at + 2);
+            at = close < 0 ? text.length : close + 2;
+        }
+        else {
+            return at;
+        }
+    }
+}
+/** The line, counted from one, of the first token at or after one offset of one file. */
+export function startLine(file, offset) {
+    return file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+}
 /**
  * The position of one offset of one file, rendered against the target root.
  *

package/dist/src/ref.js

@@ -1,13 +1,9 @@
 /**
- * The stable symbol reference: the identifier that names one declaration across
- * runs, across reports, in an ignore entry, in a configured root and in a
- * cross-language edge. It is built from names and containers only, so an edit above
- * a declaration leaves it unchanged, and it is compared as bytes, so there is one
- * canonical spelling per declaration and this module is where that spelling is
- * written.
- *
- * The position key of {@link ./position.ts} is the other identifier and has the
- * other job: it locates a finding inside one run, and the two never mix.
+ * The stable symbol reference: the identifier that names one declaration across runs,
+ * reports, ignore entries, configured roots and cross-language edges. It is built from
+ * names and containers only, so an edit above a declaration leaves it unchanged, and it
+ * is compared as bytes, so this module writes the one canonical spelling. The position
+ * key of {@link ./position.ts} locates a finding inside one run; the two never mix.
  */
 /** The language prefix, which namespaces every reference this analyzer emits. */
 const PREFIX = "ts://";
@@ -30,16 +26,10 @@ const TS_FILE = String.raw `${TS_DIRS}[^/#\r\n]+(?:(?:\.d)?\.[mc]?ts|\.tsx|\.[mc
 const SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_FILE}`;
 const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_DIRS}package\\.json`;
 /**
- * One expression per form the grammar defines, each anchored and each the whole of
- * a reference. Several forms share one expression because they differ in what the
- * symbol is rather than in how the reference is spelled, so the list is the set of
- * spellings and not the set of subjects. A reference is valid when it matches one.
- *
- * They are written here rather than read from the Contract at run time: the Contract
- * is data a reader outside this program consults, and a product that read it while
- * running would need it installed beside itself. A test compares this list against
- * the release this analyzer is written against, so a grammar that grows a form
- * arrives here as a failing test.
+ * One anchored expression per spelling the grammar defines; a reference is valid when it
+ * matches one. They are written here rather than read from the Contract at run time, so
+ * the product needs no Contract installed beside it; a test compares this list against
+ * the release this analyzer implements, so a grammar that grows a form fails it.
  */
 export const REF_EXPRESSIONS = [
     `^${SCOPE}#$`,
@@ -102,7 +92,8 @@ export function aliasFragment(name, block) {
     const head = block === undefined ? "" : `${quoted(block)}.`;
     return `${head}${nameComponent(name)}:alias`;
 }
-function spell(component) {
+/** The canonical spelling of one component: a name, or a computed key. */
+export function spell(component) {
     return component.computed ? computedComponent(component.text) : nameComponent(component.text);
 }
 /**

package/dist/src/references.js

@@ -1,11 +1,11 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isStringLiteralLikeNode, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
 import { parenthesesRemoved } from "./unwrap.js";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { specifierCandidates } from "./configuration-files.js";
 import { namespaceUses } from "./namespace-objects.js";
-import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
+import { isParameterProperty, nodeKey } from "./inventory.js";
 import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
@@ -18,6 +18,8 @@ import { byPosition, isComponentFile, renderPosition } from "./position.js";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
 import { typeParameterReads } from "./type-parameter-reads.js";
 import { typeQueryAliases } from "./type-query-alias.js";
+import { hasOwnBody } from "./own-body.js";
+import { computedLoadsOf, isLoadCall } from "./unseen-loads.js";
 import { computedKeyNames, iterationReferences, keyNameOf, keyedUses, } from "./symbol-keys.js";
 import { handedOn, valuesOf } from "./value-flow.js";
 import { bytewise } from "./text/compare.js";
@@ -211,6 +213,12 @@ function moduleURLOf(node) {
     }
     return undefined;
 }
+/** The file of the target a relative specifier written in `file` names, by its source or output name. */
+function fileNamed(file, specifier, fileIdByName) {
+    return specifierCandidates(dirnamePath(file.fileName), specifier)
+        .map((path) => fileIdByName.get(path))
+        .find((id) => id !== undefined);
+}
 /** Whether one node is a string literal or a template literal with no substitution. */
 function isLiteralText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -330,6 +338,7 @@ function sitesOf(file, declarations, fileId, unread) {
     const evaluations = [];
     const wholes = [];
     const urls = [];
+    const loadCalls = [];
     const decorated = [];
     const parameterWrites = [];
     const namespaces = namespaceUses(file);
@@ -411,7 +420,10 @@ function sitesOf(file, declarations, fileId, unread) {
         }
         const url = moduleURLOf(node);
         if (url !== undefined) {
-            urls.push(url);
+            urls.push({ ...url, from: enclosing });
+        }
+        if (isLoadCall(node)) {
+            loadCalls.push({ call: node, from: enclosing });
         }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
@@ -445,6 +457,7 @@ function sitesOf(file, declarations, fileId, unread) {
         evaluations,
         wholes,
         urls,
+        loadCalls,
         decorated,
         parameterWrites,
         keyed,
@@ -611,20 +624,12 @@ function aloneIn(file, uses, writes, found) {
     return result;
 }
 /**
- * Every reference one project's own files make to the project's own declarations, in
- * position order, and the files the test-file rules classified.
- *
- * `held` is the inventory of the same project, whose declaration map is what a resolved
- * symbol is looked up in; `targetRoot` is the absolute path every position is rendered
- * against, which is the root the inventory was read against. A pass over a consumer
- * walks the consumer's files instead and renders against its root, as
- * {@link ReferenceOptions.consumer} states.
- *
- * The order is by the referencing position, then by the declaration named, the
- * declaration referencing it and the use. That is a total order because one name
- * references one declaration once from one declaration, while a chain of aliases reaches
- * several declarations at one position and a bare star re-export's specifier both reads
- * and evaluates the module it names.
+ * Every reference one project's own files make to its own declarations, and the files the
+ * test-file rules classified. `held` is the same project's inventory, where a resolved symbol
+ * is looked up; positions render against `targetRoot`, or a consumer's root as
+ * {@link ReferenceOptions.consumer} states. The order is by position, then the declaration
+ * named, the referencing declaration and the use: an alias chain or a bare star re-export
+ * names several at one position, and one name references one declaration once.
  */
 export function references(project, held, targetRoot, options) {
     const cap = options.batchCap ?? DEFAULT_BATCH_CAP;
@@ -716,7 +721,7 @@ export function references(project, held, targetRoot, options) {
      * live. A name a namespace import binds may be a use of any file.
      */
     const named = (node) => {
-        const byName = declarationsByName(held);
+        const byName = held.byName;
         const text = node.getText();
         const imported = importedNames(node.getSourceFile()).get(text) ?? [];
         return [
@@ -740,7 +745,7 @@ export function references(project, held, targetRoot, options) {
                 return;
             }
             aliased.set(id, symbol === UNANSWERED
-                ? (declarationsByName(held).get(alias.name) ?? []).map((one) => ({
+                ? (held.byName.get(alias.name) ?? []).map((one) => ({
                     id: one,
                     stepped: true,
                     guessed: true,
@@ -783,6 +788,9 @@ export function references(project, held, targetRoot, options) {
         return { file, fileId, ...sitesOf(file, declarations, fileId, unread) };
     });
     const fileIdByName = new Map(walked.filter((one) => fileIds.has(one.fileId)).map((one) => [one.file.fileName, one.fileId]));
+    const loadable = walked
+        .filter((one) => fileIds.has(one.fileId))
+        .map(({ file, fileId }) => ({ file, fileId }));
     const contextual = contextualUses(project, held, chains, walked.flatMap((one) => one.literals), walked.flatMap((one) => one.flows), cap, tables);
     const writtenBy = new Map();
     for (const write of contextual.writes) {
@@ -862,8 +870,9 @@ export function references(project, held, targetRoot, options) {
         }
     }
     const keyNames = computedKeyNames(held.symbols);
-    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated, parameterWrites, keyed, } of walked) {
+    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, loadCalls, decorated, parameterWrites, keyed, } of walked) {
         const test = testFile.get(file) === true;
+        const loads = computedLoadsOf(file, loadCalls, loadable);
         // A component file's markup may use any binding its blocks declare at the top level.
         const markup = isComponentFile(file);
         const bindings = markup ? importBindings(file) : [];
@@ -904,6 +913,10 @@ export function references(project, held, targetRoot, options) {
                 ...wholes.map((whole) => whole.specifier),
                 ...urls.flatMap((url) => url.constructor ?? []),
                 ...bindings.map((binding) => binding.node),
+                ...loads.flatMap((load) => [
+                    ...(load.require === undefined ? [] : [load.require]),
+                    ...(load.asset ? [] : load.files.map((loaded) => loaded.file)),
+                ]),
             ]),
         ];
         const answered = new Map();
@@ -939,6 +952,18 @@ export function references(project, held, targetRoot, options) {
                 });
             }
         }
+        // A script declares no module, so the checker names nothing for a specifier of one;
+        // the compiler's module resolution still names its file.
+        const unnamed = evaluations.flatMap(({ node }) => answered.get(node) === undefined &&
+            isStringLiteralLikeNode(node) &&
+            queriedFile(file, node, fileIdByName) === undefined
+            ? [node]
+            : []);
+        const resolved = project.resolvedFileNames(unnamed);
+        const scripts = new Map(unnamed.map((node, at) => {
+            const name = resolved[at];
+            return [node, name === undefined ? undefined : fileIdByName.get(name)];
+        }));
         for (const evaluation of evaluations) {
             const queried = queriedFile(file, evaluation.node, fileIdByName);
             if (queried !== undefined) {
@@ -952,6 +977,17 @@ export function references(project, held, targetRoot, options) {
                 });
             }
             const module = answered.get(evaluation.node);
+            const script = scripts.get(evaluation.node);
+            if (script !== undefined) {
+                found.push({
+                    from: evaluation.from,
+                    to: script,
+                    position: renderPosition(file, root, evaluation.node.getStart()),
+                    use: "evaluation",
+                    resolution: "syntax",
+                    test,
+                });
+            }
             if (module === undefined) {
                 continue;
             }
@@ -973,19 +1009,13 @@ 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.length > 0 &&
-                constructor.declarations.every((handle) => ownPaths.has(handle.path))) {
+            if (typeof constructor === "object" && hasOwnBody(project, constructor)) {
                 continue;
             }
-            const loaded = specifierCandidates(dirnamePath(file.fileName), url.specifier)
-                .map((path) => fileIdByName.get(path))
-                .find((id) => id !== undefined);
+            const loaded = fileNamed(file, url.specifier, fileIdByName);
             if (loaded !== undefined) {
                 found.push({
-                    from: fileId,
+                    from: url.from,
                     to: loaded,
                     position: renderPosition(file, root, url.at.getStart()),
                     use: "evaluation",
@@ -994,6 +1024,37 @@ export function references(project, held, targetRoot, options) {
                 });
             }
         }
+        // A computed load imports each file it loads where the call is written, reading what
+        // the file exports unless it reads the file as text or a URL; hasOwnBody owns which
+        // `require` loads nothing.
+        for (const load of loads) {
+            const callee = load.require === undefined ? undefined : answered.get(load.require);
+            if (typeof callee === "object" && hasOwnBody(project, callee)) {
+                continue;
+            }
+            const position = renderPosition(file, root, load.call.getStart());
+            for (const loaded of load.files) {
+                found.push({
+                    from: load.eager ? fileId : load.from,
+                    to: loaded.fileId,
+                    position,
+                    use: "evaluation",
+                    resolution: "syntax",
+                    test,
+                });
+                const module = load.asset ? undefined : answered.get(loaded.file);
+                for (const target of module === undefined ? [] : exportsRead(module)) {
+                    found.push({
+                        from: load.from,
+                        to: target.id,
+                        position,
+                        use: "read",
+                        resolution: target.guessed ? "by-name" : "batch",
+                        test,
+                    });
+                }
+            }
+        }
         for (const whole of wholes) {
             const module = answered.get(whole.specifier);
             if (module === undefined) {
@@ -1060,7 +1121,7 @@ export function references(project, held, targetRoot, options) {
             }
             const position = renderPosition(file, root, read.key.getStart());
             const targets = symbol === UNANSWERED
-                ? (declarationsByName(held).get(read.name) ?? []).map((id) => ({
+                ? (held.byName.get(read.name) ?? []).map((id) => ({
                     id,
                     stepped: false,
                     guessed: true,

package/dist/src/session.js

@@ -138,6 +138,9 @@ function viewOf(project, configFile, engine, log) {
             ownKeys ??= new Set(ownSourceFiles().map((file) => file.path));
             return ownKeys;
         },
+        resolvedFileNames: (specifiers) => batched(engine, specifiers, (node) => project.program.getResolvedModuleFromModuleSpecifier.gen(node, node.getSourceFile().fileName)).map((resolved) => resolved === undefined || resolved.resolvedFileName === ""
+            ? undefined
+            : resolved.resolvedFileName),
         handle: (node) => ({ node }),
         symbolsAt: (handles, cap) => queries.symbolsAt(handles.map(({ node }) => node), cap),
         resolvedSymbolAt: ({ node }) => queries.resolvedSymbol(node),

package/dist/src/suppress-inline.js

@@ -4,12 +4,12 @@
  * below it, or on its own line where it trails a token there.
  */
 import { CODE } from "./contract/contract.generated.js";
-import { isConstructorDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SyntaxKind } from "@typescript/native/ast";
 import { importBindings } from "./import-bindings.js";
-import { isParameterProperty, nodeKey } from "./inventory.js";
-import { byPosition, positionKey, renderPosition } from "./position.js";
+import { nodeKey } from "./inventory.js";
+import { relativePath } from "./paths.js";
+import { byPosition, lineEnd, positionKey, renderPosition, startLine, tokenStart, } from "./position.js";
 import { importRef } from "./ref.js";
-import { signatureOf } from "./signatures.js";
 import { isPartKind, SuppressionError, siteText, } from "./suppress.js";
 /**
  * The three expressions the grammar applies to the text of each line comment, in this
@@ -55,43 +55,6 @@ const LITERALS = new Set([
     SyntaxKind.RegularExpressionLiteral,
     SyntaxKind.JsxText,
 ]);
-/** Whether one character ends a line, under the language's line terminators. */
-function endsLine(char) {
-    return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
-}
-/** The offset where the line holding `from` ends. */
-function lineEnd(text, from) {
-    let at = from;
-    while (at < text.length && !endsLine(text[at])) {
-        at += 1;
-    }
-    return at;
-}
-/**
- * The offset of the first token at or after `from`: whitespace, comments and a leading
- * hashbang are trivia.
- */
-export function tokenStart(text, from) {
-    let at = from;
-    if (at === 0 && text.startsWith("#!")) {
-        at = lineEnd(text, 0);
-    }
-    for (;;) {
-        if (/\s/u.test(text[at] ?? "")) {
-            at += 1;
-        }
-        else if (text.startsWith("//", at)) {
-            at = lineEnd(text, at);
-        }
-        else if (text.startsWith("/*", at)) {
-            const close = text.indexOf("*/", at + 2);
-            at = close < 0 ? text.length : close + 2;
-        }
-        else {
-            return at;
-        }
-    }
-}
 /**
  * Every `//` line comment of one file, in file order. The text between tokens is read as
  * the language reads it: a block comment holds no line comment, and the literal tokens the
@@ -140,55 +103,42 @@ function lineComments(file) {
 function bindingKey(one) {
     return `${one.declared?.id ?? ""}\u0000${one.part.id}`;
 }
+/** The placed declarations of a project by the path of the file each is in. */
+function placedByPath(held, symbols) {
+    const byPath = new Map();
+    for (const [id, placed] of held.placement) {
+        const one = symbols.get(id);
+        const holder = symbols.get(placed.holder);
+        if (one === undefined || holder === undefined) {
+            continue;
+        }
+        const at = byPath.get(one.position.path) ?? [];
+        at.push({ one, holder, startLines: placed.startLines, partLines: placed.partLines });
+        byPath.set(one.position.path, at);
+    }
+    return byPath;
+}
 /**
- * The declarations of one file by the line each begins on, the line of its first token: a
- * decorator, a modifier or the keyword. A variable's first token is its statement's
- * keyword, and a variable written on a later line of the statement also begins there. A
- * function also begins, for a directive, on the line of each of its parameters, and a
- * class, for a part kind, on the lines of its constructor and its constructor's parameters.
+ * The declarations of one file by the line a directive binds each on, as the inventory
+ * places them, and each import binding of the file on its statement's lines.
  */
-function declarationLines(file, held, symbols, targetRoot) {
+function declarationLines(file, placed, held, targetRoot) {
     const below = new Map();
-    const add = (offset, one) => {
-        const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+    const add = (line, one) => {
         const at = below.get(line) ?? [];
         if (!at.some((known) => bindingKey(known) === bindingKey(one))) {
             at.push(one);
         }
         below.set(line, at);
     };
-    const declaredAt = (node) => {
-        const id = held.declarations.get(nodeKey(file, node));
-        return id === undefined ? undefined : symbols.get(id);
-    };
-    const visit = (node) => {
-        const one = declaredAt(node);
-        const owner = isConstructorDeclaration(node) ? declaredAt(node.parent) : undefined;
-        if (owner !== undefined && isConstructorDeclaration(node)) {
-            for (const at of [node, ...node.parameters.filter((one) => !isParameterProperty(one))]) {
-                add(at.pos, { declared: undefined, part: owner });
-            }
-        }
-        const holder = one !== undefined && isParameterProperty(node) ? declaredAt(node.parent.parent) : one;
-        if (one !== undefined && holder !== undefined) {
-            add(node.pos, { declared: one, part: holder });
+    for (const { one, holder, startLines, partLines } of placed) {
+        for (const line of startLines) {
+            add(line, { declared: one, part: holder });
         }
-        if (one !== undefined) {
-            // A parameter on a later line of a wrapped signature takes its directive on the
-            // line above it, inside the parameter list, and the directive binds the function.
-            for (const parameter of signatureOf(node)?.parameters ?? []) {
-                add(parameter.pos, { declared: one, part: one });
-            }
-            const list = node.parent;
-            if (node.kind === SyntaxKind.VariableDeclaration &&
-                list.kind === SyntaxKind.VariableDeclarationList &&
-                list.parent.kind === SyntaxKind.VariableStatement) {
-                add(list.parent.pos, { declared: one, part: one });
-            }
+        for (const line of partLines) {
+            add(line, { declared: undefined, part: one });
         }
-        node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
+    }
     // An import binding is a subject of its own, bound on its line as a declaration is.
     const fileId = held.declarations.get(nodeKey(file, file));
     const moduleRef = held.symbols.find((symbol) => symbol.id === fileId)?.ref ?? "";
@@ -200,7 +150,7 @@ function declarationLines(file, held, symbols, targetRoot) {
             statement = statement.parent;
         }
         for (const at of [statement.pos, name.getStart()]) {
-            add(at, { declared: one, part: one });
+            add(startLine(file, at), { declared: one, part: one });
         }
     }
     return below;
@@ -221,13 +171,15 @@ export function inlineDirectives(project, held, targetRoot) {
     const symbols = new Map(held.symbols
         .filter((symbol) => symbol.kind !== "file")
         .map((symbol) => [symbol.id, { id: symbol.id, ref: symbol.ref, position: symbol.position }]));
+    const placed = placedByPath(held, symbols);
     const found = [];
     for (const file of project.ownSourceFiles()) {
         const comments = lineComments(file).filter((comment) => CANDIDATE.test(comment.text));
         if (comments.length === 0) {
             continue;
         }
-        const below = declarationLines(file, held, symbols, targetRoot);
+        const path = relativePath(targetRoot, file.fileName) ?? "";
+        const below = declarationLines(file, placed.get(path) ?? [], held, targetRoot);
         for (const comment of comments) {
             const site = renderPosition(file, targetRoot, comment.offset);
             const target = trails(file, comment.offset) ? site.line : site.line + 1;