@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/src/print.ts

@@ -1,96 +1,16 @@
-import {
-  renderOrigin,
-  type Config,
-  type DeclarationEntry,
-  type Provenance,
-  type Provider,
-} from "./config.ts";
-
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry: DeclarationEntry): Record<string, string> {
-  switch (entry.shape) {
-    case "symbol":
-      return { symbol: entry.symbol };
-    case "module":
-      return { module: entry.module, name: entry.name };
-    case "global":
-      return { global: entry.global };
-  }
-}
-
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry: Provider): Record<string, unknown> {
-  const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-  if (entry.shape === "installed") {
-    return installed;
-  }
-  return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
+import { renderOrigin, type Provenance, type ResolvedConfig } from "./config.ts";
+import { bytewise } from "./text/compare.ts";
 
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
-export function printConfig(config: Config, provenance: Provenance): string {
-  const document = {
-    contract_version: config.contractVersion,
-    target: { kind: config.targetKind },
-    analysis: {
-      languages: config.analysis.languages,
-      min_confidence: config.analysis.minConfidence,
-      generated_files: config.analysis.generatedFiles,
-      consumer_tests: config.analysis.consumerTests,
-      configurations: config.analysis.configurations.map((entry) =>
-        entry.shape === "project"
-          ? { id: entry.id, project: entry.project }
-          : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags },
-      ),
-      matrix: { complete: config.analysis.matrixComplete },
-      template_dirs: config.analysis.templateDirs,
-      template_delimiters: {
-        left: config.analysis.templateDelimiters.left,
-        right: config.analysis.templateDelimiters.right,
-      },
-    },
-    consumers: { complete: config.consumersComplete },
-    roots: { patterns: config.rootPatterns },
-    severity: Object.fromEntries([...config.severity].sort(([a], [b]) => (a < b ? -1 : 1))),
-    exemptions: { disabled: config.exemptionsDisabled },
-    reporters: {
-      formats: config.reporters.formats,
-      sort: config.reporters.sort,
-      cascade: config.reporters.cascade,
-      max_findings: config.reporters.maxFindings,
-      fail_on: config.reporters.failOn,
-    },
-    providers: { analyzers: config.providers.analyzers.map(providerOf) },
-    go: {},
-    ts: {
-      test_files: config.ts.testFiles,
-      entry_files: config.ts.entryFiles,
-      component_extensions: config.ts.componentExtensions,
-      disabled_conventions: config.ts.disabledConventions,
-      injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-      lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-        components: entry.components.map(declarationOf),
-        bases: entry.bases.map(declarationOf),
-        members: entry.members,
-      })),
-      serializers: config.ts.serializers.map(declarationOf),
-      roots_complete: config.ts.rootsComplete,
-    },
-    provenance: Object.fromEntries(
-      [...provenance]
-        .sort(([a], [b]) => (a < b ? -1 : 1))
-        .map(([path, origin]) => [path, renderOrigin(origin)]),
-    ),
-  };
-  return `${JSON.stringify(document, undefined, 2)}\n`;
+export function printConfig(config: ResolvedConfig, provenance: Provenance): string {
+  const origins = [...provenance]
+    .sort(([a], [b]) => bytewise(a, b))
+    .map(([path, origin]): [string, string] => [path, renderOrigin(origin)]);
+  return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, undefined, 2)}\n`;
 }

package/src/product.ts

@@ -0,0 +1,18 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.ts";
+import type { Writer } from "./run.ts";
+
+/** The language this analyzer reads. */
+export const LANGUAGE = "ts";
+
+/** The analyzer's name: the one its language's row names, which every output spells it with. */
+export const PRODUCT = LANGUAGE_ROWS[LANGUAGE].analyzer;
+
+/** Writes one diagnostic line to the error stream, named for the analyzer. */
+export function diagnose(err: Writer, text: string): void {
+  err.write(`${PRODUCT}: ${text}\n`);
+}
+
+/** The text one thrown value carries. */
+export function message(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

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/ref.ts

@@ -52,6 +52,7 @@ export const REF_EXPRESSIONS: readonly string[] = [
   `^${SCOPE}#${TS_HEAD}:import$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
+  `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+\\.${TS_QUOTED}:case$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
   `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
   `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,

package/src/references.ts

@@ -15,7 +15,10 @@ import {
   isIdentifier,
   isImportDeclaration,
   isImportEqualsDeclaration,
+  isInterfaceDeclaration,
   isMetaProperty,
+  isModuleBlock,
+  isModuleDeclaration,
   isNewExpression,
   isNamespaceExport,
   isNoSubstitutionTemplateLiteral,
@@ -35,13 +38,13 @@ import {
   type ParameterDeclaration,
   type SourceFile,
 } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.ts";
 import type { Symbol as TSSymbol } from "@typescript/native/sync";
 import { aliasChains, type ChainTarget } from "./alias-chain.ts";
 import { contextualUses, type FlowAt, type LiteralAt } from "./contextual-uses.ts";
 import { destructuring, propertyReadsOf, type PropertyRead } from "./destructuring.ts";
 import { specifierCandidates } from "./configuration-files.ts";
 import { namespaceUses } from "./namespace-objects.ts";
-import { globExpression } from "./glob.ts";
 import {
   declarationsByName,
   isParameterProperty,
@@ -49,7 +52,7 @@ import {
   type Inventory,
   type InventorySymbol,
 } from "./inventory.ts";
-import { augmentationReferences } from "./augmentations.ts";
+import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.ts";
 import { elementAccessReferences } from "./element-access.ts";
 import { indexedAccessReferences } from "./indexed-access.ts";
 import { keyofComparisonReferences } from "./keyof-comparisons.ts";
@@ -70,6 +73,8 @@ import {
   type KeyedAccess,
 } from "./symbol-keys.ts";
 import { handedOn, valuesOf } from "./value-flow.ts";
+import { bytewise } from "./text/compare.ts";
+import { globExpression } from "./text/glob.ts";
 
 /**
  * Every use one project's own files make of the project's own declarations.
@@ -312,15 +317,6 @@ function isName(node: Node): boolean {
   return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
 }
 
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node: Node): Node {
-  let held = node;
-  while (isParenthesizedExpression(held)) {
-    held = held.expression;
-  }
-  return held;
-}
-
 /**
  * Records the name one store writes into.
  *
@@ -330,7 +326,7 @@ function unparenthesized(node: Node): Node {
  * target writes each name it binds, through its spreads and nested patterns.
  */
 function markWrite(target: Node, writes: Set<number>, accesses: Set<Node>): void {
-  const held = unparenthesized(target);
+  const held = parenthesesRemoved(target);
   if (isName(held)) {
     writes.add(held.pos);
     return;
@@ -345,7 +341,7 @@ function markWrite(target: Node, writes: Set<number>, accesses: Set<Node>): void
     accesses.add(held);
     // A store through a member's value lands in storage every holder of the value
     // reads, so it reads the member; a variable only ever stored into stays written.
-    if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
+    if (!isPropertyAccessExpression(parenthesesRemoved(held.expression))) {
       markWrite(held.expression, writes, accesses);
     }
     return;
@@ -521,7 +517,7 @@ interface FileSites {
 
 /** Whether one node is `import.meta.url`. */
 function isImportMetaURL(node: Node): boolean {
-  const at = unparenthesized(node);
+  const at = parenthesesRemoved(node);
   return (
     isPropertyAccessExpression(at) &&
     isMetaProperty(at.expression) &&
@@ -533,7 +529,7 @@ function isImportMetaURL(node: Node): boolean {
 /** The module URL one node builds, where it builds one. */
 function moduleURLOf(node: Node): ModuleURL | undefined {
   const relative = (argument: Node | undefined): string | undefined => {
-    const at = argument === undefined ? undefined : unparenthesized(argument);
+    const at = argument === undefined ? undefined : parenthesesRemoved(argument);
     return at !== undefined &&
       (isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at)) &&
       /^\.\.?\//u.test(at.text)
@@ -548,7 +544,7 @@ function moduleURLOf(node: Node): ModuleURL | undefined {
       : undefined;
   }
   if (isCallExpression(node)) {
-    const callee = unparenthesized(node.expression);
+    const callee = parenthesesRemoved(node.expression);
     const specifier = relative(node.arguments[0]);
     if (
       specifier !== undefined &&
@@ -866,7 +862,7 @@ export function testFileRulesOf(
       };
     }),
     ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
-  ].sort((a, b) => compare(a.rule, b.rule));
+  ].sort((a, b) => bytewise(a.rule, b.rule));
 }
 
 const importedCache = new WeakMap<
@@ -1000,7 +996,7 @@ function aloneIn(
           nodes.every((node) => sameTarget.some((one) => inside(node, one.value))),
       )
       .map(([name]) => name)
-      .sort(compare);
+      .sort(bytewise);
     if (names.length > 0) {
       result.push({ index: write.index, names });
     }
@@ -1008,14 +1004,6 @@ function aloneIn(
   return result;
 }
 
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * 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.
@@ -1610,6 +1598,39 @@ export function references<Brand>(
     }
   }
 
+  /** The ambient global interfaces of the walked files that merge into a declaration outside the project's own files. */
+  const libraryMerged = (scripts: ReadonlySet<string>): ReadonlySet<string> => {
+    const names = new Map<string, Node>();
+    const visit = (node: Node): void => {
+      if (isInterfaceDeclaration(node)) {
+        const id = declaredAt(node);
+        if (id !== undefined) {
+          names.set(id, node.name);
+        }
+      } else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+        node.forEachChild(visit);
+      }
+    };
+    for (const { file } of walked) {
+      file.forEachChild(visit);
+    }
+    const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+    const asked = [...names].filter(([id]) => global.has(id));
+    if (asked.length === 0) {
+      return new Set();
+    }
+    const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+    return new Set(
+      asked.flatMap(([id], at) => {
+        const symbol = answers[at];
+        return typeof symbol === "object" &&
+          symbol.declarations.some((handle) => !ownPaths.has(handle.path))
+          ? [id]
+          : [];
+      }),
+    );
+  };
+
   const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
   for (const [file, writes] of valued) {
     const uses = usesOf.get(file) ?? [];
@@ -1637,13 +1658,13 @@ export function references<Brand>(
   const scripts = new Set(
     walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId),
   );
-  found.push(...augmentationReferences(held, found, scripts));
+  found.push(...augmentationReferences(held, found, scripts, libraryMerged(scripts)));
   found.sort(
     (a, b) =>
       byPosition(a.position, b.position) ||
-      compare(a.to, b.to) ||
-      compare(a.from, b.from) ||
-      compare(a.use, b.use),
+      bytewise(a.to, b.to) ||
+      bytewise(a.from, b.from) ||
+      bytewise(a.use, b.use),
   );
 
   return {
@@ -1651,7 +1672,7 @@ export function references<Brand>(
       consumer === undefined
         ? found
         : found.map((reference) => ({ ...reference, consumer: consumer.id })),
-    testFilePaths: tests.sort(compare),
+    testFilePaths: tests.sort(bytewise),
     cost: {
       batched,
       fileBatches,

package/src/report-schema.ts

@@ -0,0 +1,68 @@
+/**
+ * Holds a report to `contract/report.schema.json` and `contract/finding.schema.json`
+ * before it is written, reading the schemas the generator copies from the Contract, so
+ * this analyzer never writes a document a reader refuses.
+ */
+
+import { REPORT_SCHEMAS, type Report } from "./contract/report.generated.ts";
+import { schemaRefusals, type SchemaRefusal } from "./schema.ts";
+
+const reportSchema = schemaRefusals(REPORT_SCHEMAS, "report.schema.json");
+
+/**
+ * What the report schema refuses in one report document, none for an instance, and, as
+ * no schema keyword can state it, a components listing that is not one entry per
+ * component a finding or an edge evaluation's finding names.
+ */
+export function reportRefusals(document: unknown): readonly SchemaRefusal[] {
+  const found = reportSchema(document);
+  return found.length > 0 ? found : listingRefusals(document as Report);
+}
+
+/** The components listing held to the components the findings name, once each. */
+function listingRefusals(report: Report): readonly SchemaRefusal[] {
+  if (report.components === undefined) {
+    return [];
+  }
+  const refuse = (pointer: string, reason: string): SchemaRefusal[] => [
+    { pointer, keyword: "components", reason, member: "" },
+  ];
+  const listed = new Set<string>();
+  for (const [i, entry] of report.components.entries()) {
+    if (listed.has(entry.id)) {
+      return refuse(
+        `/components/${String(i)}`,
+        `the entry lists component ${entry.id} a second time`,
+      );
+    }
+    listed.add(entry.id);
+  }
+  const named = [
+    ...report.findings.map(
+      (finding, i) => [`/findings/${String(i)}`, finding.component.id] as const,
+    ),
+    ...report.edge_evaluations.flatMap((one, i) =>
+      one.finding === undefined
+        ? []
+        : [[`/edge_evaluations/${String(i)}/finding`, one.finding.component.id] as const],
+    ),
+  ];
+  for (const [pointer, id] of named) {
+    if (!listed.has(id)) {
+      return refuse(
+        pointer,
+        `the finding names component ${id}, which the components listing lacks`,
+      );
+    }
+  }
+  const ids = new Set(named.map(([, id]) => id));
+  for (const [i, entry] of report.components.entries()) {
+    if (!ids.has(entry.id)) {
+      return refuse(
+        `/components/${String(i)}`,
+        `the entry lists component ${entry.id}, which no finding names`,
+      );
+    }
+  }
+  return [];
+}