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

package/src/type-errors.ts

@@ -2,12 +2,13 @@
  * What the errors a project's own files carry do to the run. An import of a module the
  * project expects and nothing provides is a setup failure. Any other error in an own file
  * is a type error: the function, method or file-level statement holding it is skipped,
- * which only ever withholds a finding. An error the compiler places in no file is read as
- * a project that cannot be analyzed.
+ * which only ever withholds a finding. `projectErrors` decides, before any of these, which
+ * errors the compiler places in no file leave the project unloaded.
  */
 
 import {
   isClassDeclaration,
+  isFunctionLikeDeclaration,
   isNoSubstitutionTemplateLiteral,
   isPropertyAccessExpression,
   isStringLiteral,
@@ -25,6 +26,7 @@ import { isAnswered } from "./query.ts";
 import type { TypeErrorSkip } from "./report.ts";
 import type { Engine, ProjectView } from "./session.ts";
 import type { SetupFailure } from "./setup-failure.ts";
+import { findWorkspace, type Workspace } from "./workspace.ts";
 
 /** The compiler's codes for an import whose module it cannot find. */
 const MODULE_NOT_FOUND: ReadonlySet<number> = new Set([2307, 2792]);
@@ -69,8 +71,6 @@ interface ProjectErrorReading {
   readonly missing: readonly SetupFailure[];
   /** The type errors, each with the unit it skips. */
   readonly skips: readonly Skip[];
-  /** The errors placed in no file, which leave the project unanalyzable. */
-  readonly failing: readonly LocatedDiagnostic[];
 }
 
 /** Where one project reads what its imports may name. */
@@ -78,11 +78,19 @@ interface ErrorContext {
   readonly host: Host;
   /** The target root, absolute. */
   readonly targetRoot: string;
-  /** The keys of the project configuration's `paths` mapping. */
-  readonly paths: readonly string[];
+  /** The project configuration's `paths` mapping. */
+  readonly paths: PathsMapping;
+  /** Whether one manifest is a workspace member's, whose dependencies the workspace installs. */
+  readonly member: (manifest: string) => boolean;
 }
 
-/** The string literal holding one offset, innermost first. */
+/** One configuration's `paths` mapping, its targets read against `base`. */
+interface PathsMapping {
+  readonly base: string;
+  readonly entries: readonly { readonly key: string; readonly targets: readonly string[] }[];
+}
+
+/** The string literal holding one offset, innermost first, a doc comment's included. */
 function literalAt(file: SourceFile, offset: number): string | undefined {
   let found: string | undefined;
   const visit = (node: Node): void => {
@@ -92,36 +100,59 @@ function literalAt(file: SourceFile, offset: number): string | undefined {
     if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
       found = node.text;
     }
+    // `forEachChild` does not enter a doc comment, where a JavaScript file imports types.
+    for (const doc of (node as { readonly jsDoc?: readonly Node[] }).jsDoc ?? []) {
+      visit(doc);
+    }
     node.forEachChild(visit);
   };
   file.forEachChild(visit);
   return found;
 }
 
-/** Whether one `paths` key matches one specifier: exactly, or around its one `*`. */
-function mappedBy(key: string, specifier: string): boolean {
+/**
+ * What one `paths` key's `*` matches in one specifier, `""` for a key with no `*` that
+ * is the specifier, or `undefined` where the key does not match it.
+ */
+function mappedBy(key: string, specifier: string): string | undefined {
   const star = key.indexOf("*");
   if (star < 0) {
-    return key === specifier;
+    return key === specifier ? "" : undefined;
   }
   const prefix = key.slice(0, star);
   const suffix = key.slice(star + 1);
-  return (
-    specifier.length >= prefix.length + suffix.length &&
+  return specifier.length >= prefix.length + suffix.length &&
     specifier.startsWith(prefix) &&
     specifier.endsWith(suffix)
-  );
+    ? specifier.slice(prefix.length, specifier.length - suffix.length)
+    : undefined;
+}
+
+/**
+ * One `paths` target, its first `*` replaced by `star` taken literally, as the compiler does:
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L1282
+ */
+function substituted(target: string, star: string): string {
+  const at = target.indexOf("*");
+  return at < 0 ? target : target.slice(0, at) + star + target.slice(at + 1);
 }
 
-/** Whether a relative import's path names something on disk, as written or with any extension. */
-function provided(host: Host, path: string): boolean {
-  if (host.kindOf(path) !== "absent") {
+/**
+ * Whether a path names something on disk, as written or with any extension; under
+ * `fileOnly`, only a file counts.
+ */
+function provided(host: Host, path: string, fileOnly: boolean): boolean {
+  const counts = (at: string): boolean =>
+    fileOnly ? host.kindOf(at) === "file" : host.kindOf(at) !== "absent";
+  if (counts(path)) {
     return true;
   }
   const dir = dirnamePath(path);
   const stem = `${path.slice(dir.length + 1)}.`;
   try {
-    return host.readDirectory(dir).some((entry) => entry.name.startsWith(stem));
+    return host
+      .readDirectory(dir)
+      .some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
   } catch {
     return false;
   }
@@ -158,6 +189,21 @@ function declaringManifest(
   }
 }
 
+/**
+ * Whether a package is installed for an importer in `dir`: in the `node_modules` of
+ * `dir` or of any ancestor, above the target root too, as Node and the compiler look.
+ */
+function installed(host: Host, dir: string, name: string): boolean {
+  for (let at = dir; ; at = dirnamePath(at)) {
+    if (host.kindOf(joinPath(at, "node_modules", name)) === "directory") {
+      return true;
+    }
+    if (dirnamePath(at) === at) {
+      return false;
+    }
+  }
+}
+
 /**
  * Why one import that the compiler cannot resolve names a module the project expects,
  * with the fix, or undefined where the module is one the project does not expect.
@@ -170,22 +216,40 @@ function expectedModule(
   const { host, targetRoot } = context;
   const fix = "run the generator or the build that writes it";
   if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
-    return provided(host, resolvePath(dirnamePath(importer), specifier))
+    return provided(host, resolvePath(dirnamePath(importer), specifier), false)
       ? undefined
       : `which names no file of the target: ${fix}`;
   }
   if (specifier.startsWith("#")) {
     return `which the manifest's imports map to no file: ${fix}`;
   }
-  if (context.paths.some((key) => mappedBy(key, specifier))) {
-    return `which the compiler configuration's paths map to no file: ${fix}`;
-  }
+  const mapped = context.paths.entries.flatMap(({ key, targets }) => {
+    const star = mappedBy(key, specifier);
+    return star === undefined
+      ? []
+      : targets.map((target) => resolvePath(context.paths.base, substituted(target, star)));
+  });
   const name = packageOfSpecifier(specifier);
+  // The compiler looks up in `node_modules` what `paths` does not resolve, so the error
+  // of an installed package's import is the import's own, a subpath its exports omit:
+  // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L548-L575
+  if (name !== undefined && installed(host, dirnamePath(importer), name)) {
+    return undefined;
+  }
+  if (mapped.length > 0) {
+    return mapped.some((path) => provided(host, path, true))
+      ? undefined
+      : `which the compiler configuration's paths map to no file: ${fix}`;
+  }
   const manifest =
     name === undefined
       ? undefined
       : declaringManifest(host, dirnamePath(importer), targetRoot, name);
-  if (manifest === undefined) {
+  // No run requires a nested package that is no workspace member to be installed.
+  if (
+    manifest === undefined ||
+    (dirnamePath(manifest) !== targetRoot && !context.member(manifest))
+  ) {
     return undefined;
   }
   const where = relativePath(targetRoot, manifest) ?? manifest;
@@ -193,13 +257,27 @@ function expectedModule(
 }
 
 /**
- * The unit a type error at one offset skips: the class member holding it where a
- * top-level class does, else the top-level statement.
+ * The unit a type error at one offset skips: the innermost function holding it, else the
+ * class member holding it where a top-level class does, else the top-level statement.
  */
 function unitAt(file: SourceFile, offset: number): Node | undefined {
   const statement = file.statements.find((one) => one.pos <= offset && offset < one.end);
-  if (statement === undefined || !isClassDeclaration(statement)) {
-    return statement;
+  if (statement === undefined) {
+    return undefined;
+  }
+  let innermost: Node | undefined;
+  const visit = (node: Node): void => {
+    if (offset < node.getStart() || offset >= node.end) {
+      return;
+    }
+    if (isFunctionLikeDeclaration(node)) {
+      innermost = node;
+    }
+    node.forEachChild(visit);
+  };
+  visit(statement);
+  if (innermost !== undefined || !isClassDeclaration(statement)) {
+    return innermost ?? statement;
   }
   return statement.members.find((one) => one.pos <= offset && offset < one.end) ?? statement;
 }
@@ -218,19 +296,23 @@ function messageOf(text: string, targetRoot: string): string {
 export function readErrors<Brand>(
   project: ProjectView<Brand>,
   errors: readonly LocatedDiagnostic[],
-  context: ErrorContext,
+  where: Omit<ErrorContext, "member">,
 ): ProjectErrorReading {
+  let workspace: Workspace | undefined | null = null;
+  const context: ErrorContext = {
+    ...where,
+    member: (manifest) => {
+      if (workspace === null) {
+        workspace = findWorkspace(where.host, where.targetRoot, () => undefined);
+      }
+      return workspace?.memberOf(manifest) !== undefined;
+    },
+  };
   const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
   const missing: SetupFailure[] = [];
   const skips: Skip[] = [];
-  const failing: LocatedDiagnostic[] = [];
-  for (const located of errors) {
-    const { diagnostic, at } = located;
-    if (diagnostic.fileName === undefined) {
-      failing.push(located);
-      continue;
-    }
-    const file = files.get(diagnostic.fileName);
+  for (const { diagnostic, at } of errors) {
+    const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
     if (file === undefined || diagnostic.reportsUnnecessary === true) {
       continue;
     }
@@ -257,7 +339,7 @@ export function readErrors<Brand>(
       });
     }
   }
-  return { missing, skips, failing };
+  return { missing, skips };
 }
 
 /** The lines each skip withholds, below the target root. */
@@ -330,12 +412,21 @@ export function skippedRoots<Brand>(
   return [...kept];
 }
 
-/** The keys of one compiler configuration's `paths` mapping, none where it cannot be read. */
-export function pathsOf(engine: Engine, configFile: string): readonly string[] {
+/** One compiler configuration's `paths` mapping, empty where it cannot be read. */
+export function pathsOf(engine: Engine, configFile: string): PathsMapping {
+  const base = dirnamePath(configFile);
   try {
-    const paths: unknown = engine.parseConfigFile(configFile).options.paths;
-    return typeof paths === "object" && paths !== null ? Object.keys(paths) : [];
+    const { options } = engine.parseConfigFile(configFile);
+    const { paths } = options;
+    // The parse answers `pathsBasePath`, the directory of the configuration that writes
+    // `paths` (an extended one included), though the client's option type omits it:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/tsoptions/tsconfigparsing.go#L1120
+    const declaredAt = (options as { readonly pathsBasePath?: unknown }).pathsBasePath;
+    return {
+      base: typeof declaredAt === "string" ? declaredAt : base,
+      entries: Object.entries(paths ?? {}).map(([key, targets]) => ({ key, targets })),
+    };
   } catch {
-    return [];
+    return { base, entries: [] };
   }
 }

package/src/type-parameter-reads.ts

@@ -0,0 +1,227 @@
+/**
+ * The members a read through a value typed by a type parameter reaches: `value.kind`,
+ * where `value` is of a type parameter `T` of a generic function, reads `kind` on each
+ * object type no class declares that a call of the function passes for `T`, because the
+ * call's value is what the read reads, whatever member of the constraint the name resolves
+ * to. A class's members a constraint requires are interface satisfaction's.
+ */
+
+import {
+  isBinaryExpression,
+  isCallExpression,
+  isIdentifier,
+  isNewExpression,
+  isPropertyAccessExpression,
+  isTypeParameterDeclaration,
+  SyntaxKind,
+  type CallExpression,
+  type NewExpression,
+  type Node,
+  type PropertyAccessExpression,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { SymbolFlags, type Type } from "@typescript/native/sync";
+import type { AliasChains } from "./alias-chain.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
+import { renderPosition } from "./position.ts";
+import { isAnswered } from "./query.ts";
+import type { Reference } from "./references.ts";
+import type { ProjectView } from "./session.ts";
+
+/** How deep a parameter's type is matched against the type a call passes: `readonly T[]` is one level. */
+const MATCH_DEPTH = 3;
+
+/** One read of a member through a value whose type is a type parameter. */
+interface Read {
+  readonly file: SourceFile;
+  readonly from: string;
+  readonly access: PropertyAccessExpression;
+}
+
+/** A node that declares parameters, as a generic function does. */
+type Generic = Node & {
+  readonly parameters?: readonly Node[];
+};
+
+/** The name a call reaches one generic by: its own, or that of what holds it. */
+function nameOf(generic: Generic): string | undefined {
+  const own = (generic as { readonly name?: Node }).name;
+  const holder = (generic.parent as { readonly name?: Node } | undefined)?.name;
+  const name = own ?? holder;
+  return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+
+/** Whether a property access is the target of a plain assignment, which writes the member. */
+function assignedTo(access: PropertyAccessExpression): boolean {
+  const parent = access.parent;
+  return (
+    isBinaryExpression(parent) &&
+    parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+    parent.left === access
+  );
+}
+
+/**
+ * The references the reads through type-parameter-typed values of one project's own files
+ * make to the members of the types its calls pass, each made by the declaration holding
+ * the read.
+ */
+export function typeParameterReads<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  root: string,
+  testFiles: ReadonlySet<string>,
+): readonly Reference[] {
+  const queries = project.queries;
+  const reads: Read[] = [];
+  const calls: (CallExpression | NewExpression)[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const fileId = held.declarations.get(nodeKey(file, file));
+    if (fileId === undefined) {
+      continue;
+    }
+    const visit = (node: Node, from: string, generic: boolean): void => {
+      const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+      const inside =
+        generic ||
+        (node as { readonly typeParameters?: readonly Node[] }).typeParameters !== undefined;
+      if (
+        inside &&
+        isPropertyAccessExpression(node) &&
+        isIdentifier(node.name) &&
+        !assignedTo(node)
+      ) {
+        reads.push({ file, from: holder, access: node });
+      }
+      if (isCallExpression(node) || isNewExpression(node)) {
+        calls.push(node);
+      }
+      node.forEachChild((child) => {
+        visit(child, holder, inside);
+      });
+    };
+    file.forEachChild((child) => {
+      visit(child, fileId, false);
+    });
+  }
+  if (reads.length === 0) {
+    return [];
+  }
+
+  // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
+  const receivers = queries.typesAt(reads.map((read) => read.access.expression));
+  const byGeneric = new Map<Generic, { read: Read; parameter: Type }[]>();
+  reads.forEach((read, at) => {
+    const type = receivers[at];
+    if (type === undefined || !isAnswered(type) || !type.isTypeParameter()) {
+      return;
+    }
+    const symbol = queries.symbolOfType(type);
+    const declaration =
+      symbol === undefined || !isAnswered(symbol)
+        ? undefined
+        : symbol.declarations
+            .map((handle) => project.declarationAt(handle)?.node)
+            .find((node) => node !== undefined && isTypeParameterDeclaration(node));
+    const generic = declaration?.parent as Generic | undefined;
+    if (generic !== undefined) {
+      byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
+    }
+  });
+  if (byGeneric.size === 0) {
+    return [];
+  }
+
+  /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+  const passedFor = (
+    parameter: Type,
+    declared: Type,
+    instantiated: Type,
+    depth: number,
+  ): readonly Type[] => {
+    if (declared.id === parameter.id) {
+      return [instantiated];
+    }
+    if (depth >= MATCH_DEPTH) {
+      return [];
+    }
+    const a = queries.typeArguments(declared);
+    const b = queries.typeArguments(instantiated);
+    if (!isAnswered(a) || !isAnswered(b) || a.length !== b.length) {
+      return [];
+    }
+    return a.flatMap((one, at) => {
+      const other = b[at];
+      return other === undefined ? [] : passedFor(parameter, one, other, depth + 1);
+    });
+  };
+
+  // Only a call spelling a generic's name is resolved: one request each.
+  const spelled = new Set([...byGeneric.keys()].flatMap((generic) => nameOf(generic) ?? []));
+  const found = new Map<string, Reference>();
+  for (const call of calls) {
+    const callee = call.expression;
+    const written = isIdentifier(callee)
+      ? callee.text
+      : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+        ? callee.name.text
+        : undefined;
+    if (written === undefined || !spelled.has(written)) {
+      continue;
+    }
+    const resolved = queries.resolvedSignature(call);
+    if (resolved === undefined || !isAnswered(resolved) || resolved.declaration === undefined) {
+      continue;
+    }
+    const generic = project.declarationAt(resolved.declaration)?.node as Generic | undefined;
+    const pending = generic === undefined ? undefined : byGeneric.get(generic);
+    const declared = pending === undefined ? undefined : queries.genericOf(resolved);
+    if (pending === undefined || declared === undefined || !isAnswered(declared)) {
+      continue;
+    }
+    const count = (generic?.parameters ?? []).length;
+    for (const { read, parameter } of pending) {
+      const passed: Type[] = [];
+      for (let at = 0; at < count; at += 1) {
+        const own = queries.parameterType(declared, at);
+        const given = queries.typeAtPosition(resolved, at);
+        if (own !== undefined && isAnswered(own) && isAnswered(given)) {
+          passed.push(...passedFor(parameter, own, given, 0));
+        }
+      }
+      const name = read.access.name.text;
+      const position = renderPosition(read.file, root, read.access.name.getStart());
+      for (const type of passed) {
+        const parts = type.isUnionType() ? queries.constituents(type) : [type];
+        for (const part of isAnswered(parts) ? parts : []) {
+          const owner = queries.symbolOfType(part);
+          if (
+            !isAnswered(owner) ||
+            owner === undefined ||
+            (owner.flags & SymbolFlags.Class) !== 0
+          ) {
+            continue;
+          }
+          const properties = queries.propertiesOf(part);
+          for (const property of isAnswered(properties) ? properties : []) {
+            if (property.name !== name) {
+              continue;
+            }
+            for (const to of chains.declarationsOf(property)) {
+              found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
+                from: read.from,
+                to,
+                position,
+                use: "read",
+                resolution: "batch",
+                test: testFiles.has(position.path),
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return [...found.values()];
+}

package/src/value-reach.ts

@@ -26,8 +26,12 @@ import type { Inventory } from "./inventory.ts";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
-/** The object types whose members the walk reads whatever declares them. */
-const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped;
+/**
+ * The object types whose members the walk reads whatever declares them. A reverse-mapped
+ * type has no symbol: it is the shape the checker infers from an argument the target
+ * writes against a homomorphic mapped type.
+ */
+const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped | ObjectFlags.ReverseMapped;
 
 /** The symbols of an anonymous object type the target writes as a type. */
 const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
@@ -38,7 +42,7 @@ export interface Reached {
   readonly classes: ReadonlySet<string>;
   /**
    * The members of the interfaces and object types the target writes, other than its
-   * classes: each data member, and each method named `toJSON` or `toString`.
+   * classes: each data member, and each method or getter named `toJSON` or `toString`.
    */
   readonly members: readonly TSSymbol[];
 }
@@ -51,6 +55,13 @@ interface ValueReach {
 /** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
 const CONVERSION_NAMES: ReadonlySet<string> = new Set(["toJSON", "toString"]);
 
+/**
+ * The members that can answer a conversion: a serializer reads the name with `[[Get]]`
+ * and calls what it answers, so a getter answers it as a method does:
+ * https://tc39.es/ecma262/#sec-serializejsonproperty (step 2).
+ */
+export const CONVERSION_MEMBERS = SymbolFlags.Method | SymbolFlags.GetAccessor;
+
 /**
  * The types each value is checked against by the `satisfies` expressions and type assertions
  * it is written as, through parentheses, and the innermost operand's own type where there is
@@ -147,8 +158,10 @@ export function valueReach<Brand>(
     if ((type.objectFlags & ObjectFlags.Anonymous) !== 0) {
       return (symbol.flags & LITERAL_SYMBOLS) !== 0;
     }
+    // A class the inventory holds is read as a class before this, so an own class
+    // here is one it does not hold, such as a class declared in a function.
     return (
-      (symbol.flags & SymbolFlags.Interface) !== 0 &&
+      (symbol.flags & (SymbolFlags.Interface | SymbolFlags.Class)) !== 0 &&
       symbol.declarations.every((handle) => own.has(handle.path))
     );
   };
@@ -178,12 +191,12 @@ export function valueReach<Brand>(
     return !isList && isWritten(type);
   };
 
-  /** The data members and conversion methods of one written object type. */
+  /** The data members and conversion members of one written object type. */
   const carried = (type: Type): readonly TSSymbol[] =>
     must(queries.propertiesOf(type)).filter(
       (property) =>
         (property.flags & SymbolFlags.Property) !== 0 ||
-        ((property.flags & SymbolFlags.Method) !== 0 && CONVERSION_NAMES.has(property.name)),
+        ((property.flags & CONVERSION_MEMBERS) !== 0 && CONVERSION_NAMES.has(property.name)),
     );
 
   /** The types a value of one type holds, read once per type. */

package/src/verbs/analyze.ts

@@ -12,6 +12,7 @@ import { moduleIdentity } from "../consumers.ts";
 import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
 import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.ts";
 import type { Host } from "../host.ts";
+import type { ManifestEntry } from "../manifest.ts";
 import type { NotBuilt } from "../discover.ts";
 import { partialNotes } from "../partial.ts";
 import {
@@ -22,6 +23,7 @@ import {
   type Report,
   type ReportConfiguration,
   type ReportNotBuilt,
+  type ReportNote,
 } from "../report.ts";
 import { json } from "../reporters/json.ts";
 import { RENDERINGS } from "../reporters/reporters.ts";
@@ -92,6 +94,25 @@ function runRelative(invoked: string, path: string): string {
   return below;
 }
 
+/**
+ * One note per manifest entry the run reads back to no source file: what the entry names
+ * reaches nothing, so the findings its file would have rooted are reported.
+ */
+function unmappedNotes(
+  entries: readonly ManifestEntry[],
+  targetRoot: string,
+): readonly ReportNote[] {
+  return entries.map((entry) => {
+    const named = relativePath(targetRoot, entry.path) ?? entry.path;
+    return {
+      kind: "unmapped-entry",
+      path: relativePath(targetRoot, entry.dir) ?? ".",
+      key: "ts.entry_files",
+      message: `the manifest's ${entry.member} names ${named}, which reads back to no source file of the target: name the file it is built from in ts.entry_files`,
+    };
+  });
+}
+
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped: readonly NotBuilt[], targetRoot: string): readonly ReportNotBuilt[] {
   return dropped.map((one) => {
@@ -229,6 +250,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   let partial: readonly string[];
   let warnings: readonly ComponentWarning[];
   let unread: readonly string[];
+  let unfound: readonly string[];
   try {
     const root = runRelative(invoked, targetRoot);
     const mode = { production: true };
@@ -256,6 +278,10 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       ({ configFile, reason }) =>
         `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: its component files are not read: ${reason}`,
     );
+    unfound = run.librariesUnfound.map(
+      ({ configFile, error }) =>
+        `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: ${error}: the configuration is analyzed without that library`,
+    );
     partial = partialNotes({
       notBuilt: run.notBuilt,
       unanswered: run.unanswered,
@@ -283,6 +309,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       typeErrorSkips: run.typeErrorSkips,
       unanswered: unansweredCounts(analysis),
       conventionsApplied: run.conventionsApplied,
+      notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
     });
     report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
     verdict = verdictOf(result, config);
@@ -325,7 +352,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   for (const note of partial) {
     err.write(`deadset-ts: ${note}\n`);
   }
-  for (const line of unread) {
+  for (const line of [...unread, ...unfound]) {
     err.write(`deadset-ts: ${line}\n`);
   }
   for (const warning of warnings) {

package/src/verbs/explain.ts

@@ -315,12 +315,15 @@ function reported(found: CompletedFinding): string {
 /**
  * Every finding of the run that names the declaration by its reference and reports at
  * another position: a part of it, or a suppression record naming it. Each is published under
- * the reference asked about, so an explanation leaving it out would disagree with the report.
+ * the reference asked about, or a parameter's under one it starts, so an explanation leaving
+ * it out would disagree with the report.
  */
 function namedElsewhere(findings: readonly CompletedFinding[], subject: InventorySymbol): string {
   return findings
     .filter(
-      (found) => found.symbol.ref === subject.ref && positionKey(found.position) !== subject.id,
+      (found) =>
+        (found.symbol.holder ?? found.symbol.ref) === subject.ref &&
+        positionKey(found.position) !== subject.id,
     )
     .map(
       (found) =>