@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

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";
@@ -60,9 +63,18 @@ import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./pat
 import { byPosition, isComponentFile, renderPosition, type Position } from "./position.ts";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
+import { typeParameterReads } from "./type-parameter-reads.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
-import { computedKeyNames, keyNameOf, keyedUses, type KeyedAccess } from "./symbol-keys.ts";
+import {
+  computedKeyNames,
+  iterationReferences,
+  keyNameOf,
+  keyedUses,
+  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.
@@ -305,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.
  *
@@ -323,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;
@@ -338,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;
@@ -514,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) &&
@@ -526,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)
@@ -541,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 &&
@@ -859,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<
@@ -993,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 });
     }
@@ -1001,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.
@@ -1603,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) ?? [];
@@ -1621,6 +1649,8 @@ export function references<Brand>(
     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(...iterationReferences(project, held, chains, root, new Set(tests)));
+    found.push(...typeParameterReads(project, held, chains, root, new Set(tests)));
     found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
     found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
     typedLookups = (options.requestCount?.() ?? 0) - before;
@@ -1628,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 {
@@ -1642,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 [];
+}