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

package/src/json-document.ts

@@ -7,7 +7,7 @@ import type { Position } from "./position.ts";
 
 /** The token walk over a document `JSON.parse` accepted, so every token is well formed. */
 class Walk {
-  readonly opened: number[] = [];
+  readonly starts: number[] = [];
   /** The member written twice, where one is, as the offset of its name. */
   twice: { readonly name: string; readonly offset: number } | undefined;
   private readonly text: string;
@@ -41,11 +41,11 @@ class Walk {
 
   private value(role: "document" | "array" | "record" | "other"): void {
     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 === "[") {
       this.list(role === "array" ? "record" : "other");
@@ -101,8 +101,8 @@ class Walk {
 
 /** What a walk of one document found. */
 interface DocumentWalk {
-  /** The offset of the brace opening each object of the document's array member, in order. */
-  readonly opened: readonly number[];
+  /** The offset of each element of the document's array member, in order: an object's `{`. */
+  readonly starts: readonly number[];
   /** The first member one object writes twice, at any depth, as the offset of its name. */
   readonly twice: { readonly name: string; readonly offset: number } | undefined;
 }
@@ -116,7 +116,7 @@ interface DocumentWalk {
 export function walkDocument(text: string, array: string): DocumentWalk {
   const walk = new Walk(text, array);
   walk.run();
-  return { opened: walk.opened, twice: walk.twice };
+  return { starts: walk.starts, twice: walk.twice };
 }
 
 /**

package/src/namespace-objects.ts

@@ -1,7 +1,7 @@
 /**
  * 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.
  */
@@ -9,22 +9,26 @@
 import {
   isArrowFunction,
   isAwaitExpression,
-  isBindingElement,
   isCallExpression,
+  isClassStaticBlockDeclaration,
   isElementAccessExpression,
   isExpressionStatement,
   isFunctionExpression,
+  isFunctionLikeDeclaration,
   isIdentifier,
   isImportDeclaration,
+  isModuleBlock,
   isNamespaceImport,
   isNoSubstitutionTemplateLiteral,
   isObjectBindingPattern,
   isParenthesizedExpression,
   isPropertyAccessExpression,
   isQualifiedName,
+  isSourceFile,
   isStringLiteral,
   isVariableDeclaration,
   isVariableDeclarationList,
+  isVariableStatement,
   isVoidExpression,
   NodeFlags,
   SyntaxKind,
@@ -32,6 +36,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { spellsNoBinding } from "./spelled-names.ts";
 
 /** What one use of a namespace object reads beyond the names the checker resolves. */
 type NamespaceUse =
@@ -62,23 +67,33 @@ function isLiteralImport(node: Node): boolean {
   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: Node): Node {
-  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: Node): Node {
+  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: Node, name: string, declared: Node): readonly Identifier[] {
   const found: Identifier[] = [];
   const visit = (node: Node): void => {
     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;
@@ -92,8 +107,8 @@ function occurrences(scope: Node, name: string, declared: Node): readonly Identi
 /**
  * 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: SourceFile): ReadonlyMap<Node, NamespaceUse> {
   const uses = new Map<Node, NamespaceUse>();
@@ -142,13 +157,11 @@ export function namespaceUses(file: SourceFile): ReadonlyMap<Node, NamespaceUse>
         }
         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/src/overrides.ts

@@ -26,6 +26,11 @@ import { nameComponent } from "./ref.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 
+const CLASS_DECLARATIONS: ReadonlySet<SyntaxKind> = new Set([
+  SyntaxKind.ClassDeclaration,
+  SyntaxKind.ClassExpression,
+]);
+
 /** The member kinds a subclass overrides. */
 const OVERRIDABLE: ReadonlySet<string> = new Set(["method", "class-member"]);
 
@@ -111,8 +116,11 @@ export function overrideReferences<Brand>(
         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/src/paths.ts

@@ -67,6 +67,16 @@ export function dirnamePath(path: string): string {
   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: string): string {
+  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: string, path: string): string {
   return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);

package/src/references.ts

@@ -196,10 +196,10 @@ export interface ReferenceCost {
   /** Per-type lookups for the contextual uses: each distinct type's constituents, properties and symbol. */
   readonly contextualLookups: number;
   /**
-   * The requests the passes that read members through the checker's types make: element
-   * accesses, key comparisons, instantiated signatures and values handed to unimplemented
-   * callees. They are
-   * counted where the caller measures the client, through `requestCount`, and are 0 otherwise.
+   * The requests the passes after the walk make: the bases overrides are read against,
+   * element accesses, key comparisons, instantiated signatures, values handed to
+   * unimplemented callees and the modules a `declare module` names. They are counted
+   * where the caller measures the client, through `requestCount`, and are 0 otherwise.
    */
   readonly typedLookups: number;
 }
@@ -1060,19 +1060,28 @@ export function references<Brand>(
   const fileIds = new Set(
     held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id),
   );
-  let topLevel: ReadonlyMap<string, readonly InventorySymbol[]> | undefined;
-  /** The declarations one file's top level holds. */
-  const declaredIn = (fileId: string): readonly InventorySymbol[] => {
-    if (topLevel === undefined) {
-      const byParent = new Map<string, InventorySymbol[]>();
+  let moduleBodies: ReadonlyMap<string, readonly InventorySymbol[]> | undefined;
+  /**
+   * 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: string): readonly InventorySymbol[] => {
+    if (moduleBodies === undefined) {
+      const byModule = new Map<string, InventorySymbol[]>();
       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<number, readonly ChainTarget[]>();
@@ -1431,9 +1440,12 @@ export function references<Brand>(
 
     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;
       }
@@ -1604,14 +1616,14 @@ export function references<Brand>(
 
   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),

package/src/reflective-lookup.ts

@@ -120,8 +120,9 @@ export function reflectiveLookup<Brand>(input: DetectorInput<Brand>): readonly E
     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],
@@ -131,11 +132,12 @@ export function reflectiveLookup<Brand>(input: DetectorInput<Brand>): readonly E
     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);
       }
     });

package/src/reporters/template.ts

@@ -912,7 +912,7 @@ class Execution {
       case "lit":
         return arg.value;
       case "pipe":
-        return this.pipeline(arg.pipe, dot, false);
+        return this.pipeline(arg.pipe, dot);
       case "field":
         return this.field(arg.recv === undefined ? dot : this.arg(arg.recv, dot), arg.names);
       case "func":
@@ -958,18 +958,17 @@ class Execution {
     return call(head.name, operands());
   }
 
-  private pipeline(pipe: Pipeline, dot: Value, declares: boolean): Value {
+  private pipeline(pipe: Pipeline, dot: Value): Value {
     let value: Value | undefined;
     for (const command of pipe.commands) {
       value = this.command(command, dot, value);
     }
     const result = value ?? null;
-    const [only] = pipe.vars;
-    if (only !== undefined && (declares || pipe.assign)) {
+    for (const name of pipe.vars) {
       if (pipe.assign) {
-        this.assign(only, result);
+        this.assign(name, result);
       } else {
-        this.scopes.at(-1)?.set(only, result);
+        this.scopes.at(-1)?.set(name, result);
       }
     }
     return result;
@@ -982,7 +981,7 @@ class Execution {
           this.write(node.text);
           break;
         case "action": {
-          const value = this.pipeline(node.pipe, dot, true);
+          const value = this.pipeline(node.pipe, dot);
           if (node.pipe.vars.length === 0) {
             this.write(formatted(value, false));
           }
@@ -995,7 +994,7 @@ class Execution {
         case "with": {
           this.scopes.push(new Map());
           try {
-            const value = this.pipeline(node.pipe, dot, true);
+            const value = this.pipeline(node.pipe, dot);
             const taken = truthy(value);
             this.run(taken ? node.list : node.otherwise, taken && node.k === "with" ? value : dot);
           } finally {
@@ -1013,7 +1012,9 @@ class Execution {
   private range(node: Control, dot: Value): void {
     this.scopes.push(new Map());
     try {
-      const value = this.pipeline({ ...node.pipe, vars: [] }, dot, false);
+      // Go's `evalPipeline` gives every variable the range declares or assigns the whole value first:
+      // https://github.com/golang/go/blob/go1.27.2/src/text/template/exec.go#L525
+      const value = this.pipeline(node.pipe, dot);
       let entries: [Value, Value][];
       if (value === null) {
         entries = [];
@@ -1031,13 +1032,20 @@ class Execution {
         return;
       }
       const [first, second] = node.pipe.vars;
+      const scope = this.scopes.at(-1);
+      const bind = (name: string, held: Value): void => {
+        if (node.pipe.assign) {
+          this.assign(name, held);
+        } else {
+          scope?.set(name, held);
+        }
+      };
       for (const [key, element] of entries) {
-        const scope = this.scopes.at(-1);
         if (second !== undefined && first !== undefined) {
-          scope?.set(first, key);
-          scope?.set(second, element);
+          bind(first, key);
+          bind(second, element);
         } else if (first !== undefined) {
-          scope?.set(first, element);
+          bind(first, element);
         }
         try {
           this.run(node.list, element);

package/src/serialization-contract.ts

@@ -45,6 +45,8 @@ import {
   SignatureKind,
   SymbolFlags,
   TypeFlags,
+  type NodeHandle,
+  type Signature,
   type Symbol as TSSymbol,
   type Type,
 } from "@typescript/native/sync";
@@ -64,7 +66,7 @@ import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { erasedStores, type ErasedStores } from "./erased-stores.ts";
-import { checkedTypes, valueReach, type Reached } from "./value-reach.ts";
+import { checkedTypes, CONVERSION_MEMBERS, valueReach, type Reached } from "./value-reach.ts";
 
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY: DeclarationEntry = { shape: "global", global: "JSON.stringify" };
@@ -484,14 +486,19 @@ function destinations<Brand>(
     own.has(path) || input.consumers.some((root) => path === root || path.startsWith(`${root}/`));
   const implemented = implementedOwners(project, inAnalysis);
   /**
-   * Whether every declaration of a callee is outside the analysis or ambient. An ambient
-   * declaration has no body, so the code that runs is outside the analysis, unless it is a
-   * member of an interface or an object type a class or a typed object literal of the
-   * analysis implements; `settled` false skips that question, which asks the checker.
+   * Whether every one of `declarations`, all of the callee's by default, is outside the
+   * analysis or ambient. An ambient declaration has no body, so the code that runs is
+   * outside the analysis, unless it is a member of an interface or an object type a class
+   * or a typed object literal of the analysis implements; `settled` false skips that
+   * question, which asks the checker.
    */
-  const outside = (target: TSSymbol, settled: boolean): boolean =>
-    target.declarations.length > 0 &&
-    target.declarations.every((handle) => {
+  const outside = (
+    target: TSSymbol,
+    settled: boolean,
+    declarations: readonly NodeHandle[] = target.declarations,
+  ): boolean =>
+    declarations.length > 0 &&
+    declarations.every((handle) => {
       if (!inAnalysis(handle.path)) {
         return true;
       }
@@ -505,6 +512,13 @@ function destinations<Brand>(
       const owner = must(queries.parentOf(target));
       return owner === undefined || !implemented().has(owner.id);
     });
+  /**
+   * Whether some one declaration of a callee is outside the analysis or ambient, without
+   * asking the checker. A project's declaration merged into a library's symbol leaves the
+   * library's beside it, so a call can still resolve to the library's.
+   */
+  const mayBeOutside = (target: TSSymbol): boolean =>
+    target.declarations.some((handle) => outside(target, false, [handle]));
   const invocation = (call: CallExpression): Invocation => {
     const form = forms.get(call);
     const method = form === undefined ? undefined : callees.get(form.method);
@@ -513,7 +527,7 @@ function destinations<Brand>(
     if (
       form !== undefined &&
       method !== undefined &&
-      outside(method, false) &&
+      mayBeOutside(method) &&
       FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")
     ) {
       return form.invocation;
@@ -524,6 +538,32 @@ function destinations<Brand>(
     const name = calleeName(invocation(call).callee);
     return name === undefined ? undefined : callees.get(name);
   };
+  const signatures = new Map<CallExpression, Signature | undefined>();
+  const resolvedOf = (call: CallExpression): Signature | undefined => {
+    if (!signatures.has(call)) {
+      signatures.set(call, must(queries.resolvedSignature(call)));
+    }
+    return signatures.get(call);
+  };
+  /**
+   * The declarations of a callee that the declaration of a direct call's resolved
+   * signature lies in, or all of them where it lies in none: a declaration merged into
+   * the callee's symbol that the call does not resolve to does not decide where it runs.
+   */
+  const calledDeclarations = (call: CallExpression, target: TSSymbol): readonly NodeHandle[] => {
+    const declaration = invocation(call).indirect ? undefined : resolvedOf(call)?.declaration;
+    const signature =
+      declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
+    if (declaration === undefined || signature === undefined) {
+      return target.declarations;
+    }
+    const containing = target.declarations.filter((handle) => {
+      const node =
+        handle.path === declaration.path ? project.declarationAt(handle)?.node : undefined;
+      return node !== undefined && node.pos <= signature.pos && signature.end <= node.end;
+    });
+    return containing.length === 0 ? target.declarations : containing;
+  };
   const erasedArguments = new Map<CallExpression, ReadonlySet<number>>();
   const erasedAt = (call: CallExpression, argument: number): boolean => {
     let indexes = erasedArguments.get(call);
@@ -536,7 +576,7 @@ function destinations<Brand>(
         ? type === undefined
           ? []
           : must(queries.signaturesOf(type, SignatureKind.Call))
-        : [must(queries.resolvedSignature(call))].filter((one) => one !== undefined);
+        : [resolvedOf(call)].filter((one) => one !== undefined);
       indexes = new Set(
         invoked.arguments.flatMap((_unused, index) =>
           signatures.some((signature) => {
@@ -563,7 +603,7 @@ function destinations<Brand>(
     if (entry !== undefined) {
       return { reach: "properties", callee: spelledEntry(entry.entry, held) };
     }
-    if (outside(target, true)) {
+    if (outside(target, true, calledDeclarations(call, target))) {
       return erasedAt(call, argument)
         ? {
             reach: "conversions",
@@ -602,7 +642,7 @@ function destinations<Brand>(
     if (target === undefined) {
       return false;
     }
-    if (named.some((one) => names(one, target, chains)) || outside(target, false)) {
+    if (named.some((one) => names(one, target, chains)) || mayBeOutside(target)) {
       return true;
     }
     return chains
@@ -733,7 +773,7 @@ export function serializationContract<Brand>(input: DetectorInput<Brand>): reado
   // the value left the analysis.
   const holdsBack = (flags: SymbolFlags, name: string, to: Destination): boolean =>
     (flags & SymbolFlags.Property) !== 0 ||
-    ((flags & SymbolFlags.Method) !== 0 &&
+    ((flags & CONVERSION_MEMBERS) !== 0 &&
       (name === SERIALIZED_CONVERSION || (to.reach === "conversions" && CONVERSIONS.has(name))));
   const found: Evidence[] = [];
   for (const flow of flows) {

package/src/session.ts

@@ -419,6 +419,8 @@ export interface ProjectDiagnostics {
   readonly syntactic: readonly Diagnostic[];
   readonly semantic: readonly Diagnostic[];
   readonly configParsing: readonly Diagnostic[];
+  /** The program's diagnostics placed in no file, each once, its `fileName` undefined. */
+  readonly unplaced: readonly Diagnostic[];
   /** The line and column of one offset into one of the program's files, counted from one. */
   readonly locate: (
     fileName: string,
@@ -426,12 +428,31 @@ export interface ProjectDiagnostics {
   ) => { line: number; column: number } | undefined;
 }
 
-/** The three diagnostic sets one project carries, read before any analysis. */
+/**
+ * The program's diagnostics placed in no file. The per-file sets never carry one; the
+ * client answers its `fileName` as `null`, and the global set repeats the program set:
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/api/session.go#L3726-L3752
+ */
+function unplacedOf(program: Program): readonly Diagnostic[] {
+  const seen = new Set<string>();
+  return [...program.getGlobalDiagnostics(), ...program.getProgramDiagnostics()]
+    .filter((diagnostic) => diagnostic.fileName == null)
+    .filter((diagnostic) => {
+      const key = `${String(diagnostic.code)}\u0000${diagnostic.text}`;
+      const fresh = !seen.has(key);
+      seen.add(key);
+      return fresh;
+    })
+    .map((diagnostic) => ({ ...diagnostic, fileName: undefined }));
+}
+
+/** The diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf<Brand>(project: ProjectView<Brand>): ProjectDiagnostics {
   return {
     syntactic: project.program.getSyntacticDiagnostics(),
     semantic: project.program.getSemanticDiagnostics(),
     configParsing: project.program.getConfigFileParsingDiagnostics(),
+    unplaced: unplacedOf(project.program),
     locate: (fileName, offset) => {
       const file = project.program.getSourceFile(fileName);
       if (file === undefined || offset < 0 || offset > file.text.length) {