@cplieger/deadset-ts 8.0.0-dev.3 → 8.0.0-dev.5

package/src/query.ts

@@ -211,6 +211,8 @@ export interface Queries {
   symbolOfType(type: Type): Answer<TSSymbol | undefined>;
   signaturesOf(type: Type, kind: SignatureKind): Answer<readonly Signature[]>;
   resolvedSignature(node: Node): Answer<Signature | undefined>;
+  /** The signature each call-like node resolves to. */
+  resolvedSignatures(nodes: readonly Node[], cap?: number): Answer<Signature | undefined>[];
   parameterType(signature: Signature, index: number): Answer<Type | undefined>;
   /** The generic signature an instantiated one instantiates; none for another signature. */
   genericOf(signature: Signature): Answer<Signature | undefined>;
@@ -544,6 +546,15 @@ export function queriesOf(
         () => nodeLocation(node),
         () => checker.getResolvedSignature(node),
       ),
+    resolvedSignatures: (nodes, cap = DEFAULT_BATCH_CAP) =>
+      each(
+        "getResolvedSignature",
+        nodes,
+        cap,
+        nodeLocation,
+        (node) => checker.getResolvedSignature.gen(node),
+        (node) => checker.getResolvedSignature(node),
+      ),
     parameterType: (signature, index) =>
       one(
         "getParameterType",

package/src/reporters/annotations.ts

@@ -1,8 +1,7 @@
-import { fails } from "../config.ts";
+import type { Severity } from "../config.ts";
 import { coalesced } from "../json-chunks.ts";
 import { KINDS } from "../kinds.ts";
 import type { Report } from "../report.ts";
-import type { RenderOptions } from "./reporter.ts";
 
 /** The escapes a workflow command's message needs, so a line break does not end the command. */
 const DATA_ESCAPES: Readonly<Record<string, string>> = { "%": "%25", "\r": "%0D", "\n": "%0A" };
@@ -27,8 +26,18 @@ function kindName(code: string): string {
   return KINDS.get(code)?.name ?? code;
 }
 
+/** The workflow command a record is written as. */
+type Level = "error" | "warning" | "notice";
+
+/** The command each finding severity is annotated with, whatever the failing severity. */
+const LEVELS: Readonly<Record<Severity, Level>> = {
+  deny: "error",
+  warn: "warning",
+  allow: "notice",
+};
+
 function command(
-  level: "error" | "warning",
+  level: Level,
   at: { readonly path: string; readonly line: number; readonly column: number },
   endLine: number,
   title: string,
@@ -43,18 +52,17 @@ const SKIP_MESSAGE =
   "the analysis did not evaluate the function or statement holding this type error: ";
 
 /**
- * One workflow annotation per finding, then one per stale suppression, each naming its
- * file, line, column and last line, titled by its code and kind, then one warning per
- * type-error skip naming its file and line. A finding at or above the failing severity is
- * an error and one below it a warning; a stale suppression is an error, because its kind
- * is fixed on at the failing severity.
+ * The annotations `contract/grammar/annotations.md` states: one per finding, at the
+ * command its severity names, and one error per stale suppression, each naming its file,
+ * line, column and last line and titled by its code and kind; then one warning per
+ * type-error skip naming its file and line, and one per note naming its directory.
  */
-export function annotations(report: Report, options: RenderOptions): Iterable<string> {
+export function annotations(report: Report): Iterable<string> {
   return coalesced(
     (function* lines(): Generator<string, void, undefined> {
       for (const found of report.findings) {
         yield `${command(
-          fails(found.severity, options.failOn) ? "error" : "warning",
+          LEVELS[found.severity],
           found.position,
           found.position.end_line,
           `${found.code} ${found.kind}`,
@@ -73,6 +81,9 @@ export function annotations(report: Report, options: RenderOptions): Iterable<st
       for (const skip of report.type_error_skips) {
         yield `::warning file=${escapeProperty(skip.path)},line=${String(skip.line)},title=${escapeProperty(SKIP_TITLE)}::${escapeData(SKIP_MESSAGE + skip.message)}\n`;
       }
+      for (const note of report.notes) {
+        yield `::warning file=${escapeProperty(note.path)},title=${escapeProperty(note.kind)}::${escapeData(note.message)}\n`;
+      }
     })(),
   );
 }

package/src/reporters/reporter.ts

@@ -1,11 +1,9 @@
-import type { Format, Severity } from "../config.ts";
+import type { Format } from "../config.ts";
 import type { Report } from "../report.ts";
 import type { Template } from "./template.ts";
 
 /** What a rendering reads beside the report. */
 export interface RenderOptions {
-  /** The lowest severity at which a finding fails the run. */
-  readonly failOn: Severity;
   /** The text of the file at one path below the target root, or a throw naming why not. */
   readonly readSource: (path: string) => string;
   /** The template the template rendering renders, where one was named. */

package/src/roots.ts

@@ -34,6 +34,7 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.ts";
+import { isGlobalBlock } from "./augmentations.ts";
 import {
   filesNamedBy,
   outsideChain,
@@ -680,9 +681,11 @@ const EXPORTING_CONTAINERS: ReadonlySet<string> = new Set(["file", "namespace"])
  * Every declaration a consumer of the library can name: what the published files export,
  * and below each the members a consumer writes, a namespace's exported ones and any other
  * declaration's public and protected ones. A declaration a published one's type names is
- * published too, and so is an exported declaration a release tag marks. A type name the
- * checker leaves unanswered publishes every declaration spelled as it is, as `guessed`. A
- * published file is not itself published.
+ * published too, and so is an exported declaration a release tag marks, and every
+ * declaration a `declare global` block of a published file, or of a file holding a published
+ * declaration, holds: the consumer's compiler loads that file's typings and their global
+ * scope with it. A type name the checker leaves unanswered publishes every declaration
+ * spelled as it is, as `guessed`. A published file is not itself published.
  */
 function publishedAPI<Brand>(
   project: ProjectView<Brand>,
@@ -715,57 +718,84 @@ function publishedAPI<Brand>(
       reach(id);
     }
   }
-  while (pending.length > 0) {
-    const round: string[] = [];
-    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-      round.push(next);
-      const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-      for (const member of children.get(next) ?? []) {
-        const reachable = exporting
-          ? member.exported
-          : member.visibility !== "private" && member.visibility !== "private-name";
-        if (member.kind !== "type-parameter" && reachable) {
+  const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
+  const blocks = held.symbols.filter((one) => isGlobalBlock(one, held, files));
+  const fileOf = (id: string): string | undefined => {
+    let at = byId.get(id);
+    while (at !== undefined && at.kind !== "file") {
+      at = byId.get(at.parent);
+    }
+    return at?.id;
+  };
+  const publishedFiles = published.flatMap(
+    (file) => held.declarations.get(nodeKey(file, file)) ?? [],
+  );
+  const globalsReached = (): boolean => {
+    const typed = new Set([...publishedFiles, ...[...reached].flatMap((id) => fileOf(id) ?? [])]);
+    const before = pending.length;
+    for (const block of blocks.filter((one) => typed.has(one.parent))) {
+      reach(block.id);
+      for (const member of children.get(block.id) ?? []) {
+        if (member.kind !== "type-parameter") {
           reach(member.id);
         }
       }
     }
-    const named = round.flatMap((id) => {
-      const symbol = byId.get(id);
-      return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
-    });
-    const inferred = inferredTypeSymbols(
-      project,
-      round.flatMap((id) => {
-        const symbol = byId.get(id);
-        return symbol === undefined ? [] : nodes.nodesOf(symbol);
-      }),
-    );
-    for (const symbol of inferred.types) {
-      for (const target of chains.chainOf(symbol)) {
-        reach(target.id);
+    return pending.length > before;
+  };
+  do {
+    while (pending.length > 0) {
+      const round: string[] = [];
+      for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+        round.push(next);
+        const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
+        for (const member of children.get(next) ?? []) {
+          const reachable = exporting
+            ? member.exported
+            : member.visibility !== "private" && member.visibility !== "private-name";
+          if (member.kind !== "type-parameter" && reachable) {
+            reach(member.id);
+          }
+        }
       }
-    }
-    for (const symbol of inferred.members) {
-      for (const target of chains.chainOf(symbol)) {
-        const member = byId.get(target.id);
-        if (member?.visibility === "public" || member?.visibility === "protected") {
+      const named = round.flatMap((id) => {
+        const symbol = byId.get(id);
+        return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
+      });
+      const inferred = inferredTypeSymbols(
+        project,
+        round.flatMap((id) => {
+          const symbol = byId.get(id);
+          return symbol === undefined ? [] : nodes.nodesOf(symbol);
+        }),
+      );
+      for (const symbol of inferred.types) {
+        for (const target of chains.chainOf(symbol)) {
           reach(target.id);
         }
       }
-    }
-    project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
-      if (symbol === UNANSWERED) {
-        for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
-          guessed.add(id);
-          reach(id);
-        }
-      } else if (symbol !== undefined) {
+      for (const symbol of inferred.members) {
         for (const target of chains.chainOf(symbol)) {
-          reach(target.id);
+          const member = byId.get(target.id);
+          if (member?.visibility === "public" || member?.visibility === "protected") {
+            reach(target.id);
+          }
         }
       }
-    });
-  }
+      project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
+        if (symbol === UNANSWERED) {
+          for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
+            guessed.add(id);
+            reach(id);
+          }
+        } else if (symbol !== undefined) {
+          for (const target of chains.chainOf(symbol)) {
+            reach(target.id);
+          }
+        }
+      });
+    }
+  } while (globalsReached());
   return { ids: [...reached], guessed: [...guessed] };
 }