@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/src/destructuring.ts

@@ -213,17 +213,6 @@ function sourceOf(target: Node): Source | undefined {
   }
 }
 
-/** What resolving one project's property reads cost at the client boundary. */
-interface DestructuringCost {
-  /** Batched type lookups, one per capped run of a file's patterns and assigned values. */
-  readonly patternBatches: number;
-  /**
-   * Per-type lookups: one property table per distinct destructured type, and each step
-   * an assignment target takes into its assigned value.
-   */
-  readonly patternLookups: number;
-}
-
 /** Resolves property reads to the symbols the destructured values' types declare. */
 interface Destructuring {
   /**
@@ -232,7 +221,6 @@ interface Destructuring {
    * {@link UNANSWERED} where a question about the value's type went unanswered.
    */
   resolve(reads: readonly PropertyRead[]): readonly Answer<TSSymbol | undefined>[];
-  readonly cost: DestructuringCost;
 }
 
 /** A type along a destructuring, or the mark that a question about it went unanswered. */
@@ -250,8 +238,6 @@ export function destructuring<Brand>(
 ): Destructuring {
   const queries = project.queries;
   const tables = new Map<number, Answer<ReadonlyMap<string, TSSymbol>>>();
-  let patternBatches = 0;
-  let patternLookups = 0;
 
   const tableOf = (type: Type): Answer<ReadonlyMap<string, TSSymbol>> => {
     const known = tables.get(type.id);
@@ -261,7 +247,6 @@ export function destructuring<Brand>(
     let table: Answer<ReadonlyMap<string, TSSymbol>> = new Map<string, TSSymbol>();
     if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
       const read = properties.of(type);
-      patternLookups += read.asked ? 1 : 0;
       table = isAnswered(read.properties)
         ? new Map(read.properties.map((property) => [property.name, property]))
         : UNANSWERED;
@@ -274,7 +259,6 @@ export function destructuring<Brand>(
     if ((type.flags & TypeFlags.Union) === 0) {
       return type;
     }
-    patternLookups += 1;
     return queries.nonNullable(type);
   };
 
@@ -290,11 +274,9 @@ export function destructuring<Brand>(
       if (index === undefined) {
         return undefined;
       }
-      patternLookups += 1;
       const elements = queries.typeArguments(type);
       return isAnswered(elements) ? elements[index] : UNANSWERED;
     }
-    patternLookups += 1;
     const array = queries.isArray(type);
     if (!isAnswered(array)) {
       return UNANSWERED;
@@ -302,7 +284,6 @@ export function destructuring<Brand>(
     if (!array) {
       return undefined;
     }
-    patternLookups += 1;
     const elements = queries.typeArguments(type);
     return isAnswered(elements) ? elements[0] : UNANSWERED;
   };
@@ -320,7 +301,6 @@ export function destructuring<Brand>(
     if (more.length > 0) {
       return UNANSWERED;
     }
-    patternLookups += 1;
     return queries.typeOfSymbol(property);
   };
 
@@ -328,7 +308,6 @@ export function destructuring<Brand>(
     if (callee === undefined || callee === UNANSWERED) {
       return callee;
     }
-    patternLookups += 1;
     const signatures = queries.signaturesOf(callee, SignatureKind.Call);
     if (!isAnswered(signatures)) {
       return UNANSWERED;
@@ -337,7 +316,6 @@ export function destructuring<Brand>(
     if (signature === undefined) {
       return undefined;
     }
-    patternLookups += 1;
     return queries.returnTypeOf(signature);
   };
 
@@ -369,7 +347,6 @@ export function destructuring<Brand>(
     if (result !== undefined && result !== UNANSWERED) {
       let parts: Answer<readonly Type[]> = [result];
       if (result.isUnionType()) {
-        patternLookups += 1;
         parts = queries.constituents(result);
       }
       const values: readonly Found[] = isAnswered(parts)
@@ -403,7 +380,6 @@ export function destructuring<Brand>(
       if (property === undefined) {
         return undefined;
       }
-      patternLookups += 1;
       return queries.typeOfSymbol(property);
     }
     return elementOf(defined, next.index);
@@ -425,7 +401,6 @@ export function destructuring<Brand>(
       }
     }
     const asked = [...asking];
-    patternBatches += Math.ceil(asked.length / cap);
     const answered = new Map<Node, Found>();
     queries.typesAt(asked, cap).forEach((type, index) => {
       const node = asked[index];
@@ -456,10 +431,5 @@ export function destructuring<Brand>(
     });
   };
 
-  return {
-    resolve,
-    get cost() {
-      return { patternBatches, patternLookups };
-    },
-  };
+  return { resolve };
 }

package/src/edges.ts

@@ -5,15 +5,18 @@
  * pairing is a use, and the merge reads the two evaluations together.
  */
 
-import { ConfigError } from "./config.ts";
+import { EDGES_SCHEMA } from "./contract/config.generated.ts";
 import type { Finding } from "./finding.ts";
 import type { EdgeSide, EdgeSideName } from "./findings/boundary.ts";
+import { readTargetDocument } from "./fs/document.ts";
 import type { Host } from "./host.ts";
 import type { InventorySymbol } from "./inventory.ts";
-import { positionAt, walkDocument } from "./json-document.ts";
-import { joinPath } from "./paths.ts";
+import { dotted, placeIn, positionAt, readStrict, StrictJSONError } from "./json-document.ts";
 import { positionKey } from "./position.ts";
+import { firstRefusal } from "./schema.ts";
 import { isPartSubject } from "./suppress.ts";
+import { bytewise } from "./text/compare.ts";
+import { UsageError } from "./usage.ts";
 
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
@@ -21,155 +24,61 @@ export const EDGES_FILE = "deadset-edges.json";
 /** The language prefix of every reference this analyzer evaluates. */
 const OWN_PREFIX = "ts://";
 
-/** The closed key list of the document and of one edge. */
-const DOCUMENT_KEYS: ReadonlySet<string> = new Set(["description", "edges"]);
-const EDGE_KEYS: ReadonlySet<string> = new Set(["id", "because", "provides", "used_by"]);
-
-/** An edge identifier: solidus-separated segments of ASCII letters, digits, `_`, `.` and `-`. */
-const ID_FORM = /^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/u;
-
-/** A reference naming one symbol of some language: `<language>://<scope>#<fragment>`. */
-const REFERENCE_FORM = /^[a-z][a-z0-9]*:\/\/[^ \t\r\n#]+#[^ \t\r\n]*$/u;
-
-const DOCUMENT_WANT = "an object carrying the edges array, and an optional description";
-const EDGE_WANT = "an edge naming id, provides and used_by, each a string, and an optional because";
-const ID_WANT =
-  "one or more solidus-separated segments of ASCII letters, digits, underscore, full stop and hyphen";
-const REFERENCE_WANT =
-  "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
-
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-class EdgesError extends ConfigError {
-  constructor(at: string, text: string, want: string) {
-    super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
+class EdgesError extends UsageError {
+  constructor(at: string, reason: string) {
+    super(`${at}: ${reason}`);
     this.name = "EdgesError";
   }
 }
 
-/**
- * Whether a reference carries a wildcard outside a quoted or a computed component, which
- * would name a set of symbols rather than one.
- */
-function carriesWildcard(ref: string): boolean {
-  let quoted = false;
-  let computed = false;
-  let escaped = false;
-  for (const char of ref) {
-    if (escaped) {
-      escaped = false;
-    } else if (quoted && char === "\\") {
-      escaped = true;
-    } else if (quoted) {
-      quoted = char !== "'";
-    } else if (computed) {
-      computed = char !== "]";
-    } else if (char === "'") {
-      quoted = true;
-    } else if (char === "[") {
-      computed = true;
-    } else if (char === "*") {
-      return true;
-    }
-  }
-  return false;
-}
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** One edge, checked: the closed key list, the value types and the value forms. */
-function readEdge(value: unknown, at: string): { id: string; provides: string; usedBy: string } {
-  const refuse = (text: string, want: string): never => {
-    throw new EdgesError(at, text, want);
-  };
-  if (!isObject(value)) {
-    return refuse(JSON.stringify(value), EDGE_WANT);
-  }
-  for (const [key, held] of Object.entries(value)) {
-    if (!EDGE_KEYS.has(key) || typeof held !== "string") {
-      refuse(`the member ${JSON.stringify(key)} holding ${JSON.stringify(held)}`, EDGE_WANT);
-    }
-  }
-  const edge = value as Readonly<Record<string, string | undefined>>;
-  const id = edge["id"] ?? refuse("an edge naming no id", EDGE_WANT);
-  const provides = edge["provides"] ?? refuse("an edge naming no provides side", EDGE_WANT);
-  const usedBy = edge["used_by"] ?? refuse("an edge naming no used_by side", EDGE_WANT);
-  if (!ID_FORM.test(id)) {
-    refuse(JSON.stringify(id), ID_WANT);
-  }
-  for (const ref of [provides, usedBy]) {
-    if (!REFERENCE_FORM.test(ref) || carriesWildcard(ref)) {
-      refuse(JSON.stringify(ref), REFERENCE_WANT);
-    }
-  }
-  return { id, provides, usedBy };
-}
+/** The sides of one edge, in the order a reader yields them. */
+const SIDE_NAMES: readonly EdgeSideName[] = ["provides", "used_by"];
 
 /**
  * Every side of a declared edge that names a symbol of this language, in document order,
  * `provides` before `used_by` within an edge. An absent document declares no edge. The
- * document is strict JSON with a closed key list at both levels, and a defect in it is an
- * {@link EdgesError}.
+ * document is strict JSON held to the Contract's edges schema, and a defect in it is an
+ * {@link EdgesError} at the line and column of the edge it is in, where it is in one.
  */
 export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide[] {
-  const file = joinPath(targetRoot, EDGES_FILE);
-  if (host.kindOf(file) === "absent") {
+  const text = readTargetDocument(host, targetRoot, EDGES_FILE);
+  if (text === undefined) {
     return [];
   }
-  const text = host.readFile(file);
-  let parsed: unknown;
+  let read;
   try {
-    parsed = JSON.parse(text);
+    read = readStrict(text, "edges");
   } catch (error: unknown) {
-    throw new EdgesError(
-      EDGES_FILE,
-      error instanceof Error ? error.message : String(error),
-      DOCUMENT_WANT,
-    );
-  }
-  if (!isObject(parsed)) {
-    throw new EdgesError(EDGES_FILE, JSON.stringify(parsed), DOCUMENT_WANT);
-  }
-  const walk = walkDocument(text, "edges");
-  if (walk.twice !== undefined) {
-    throw new EdgesError(
-      positionKey(positionAt(text, EDGES_FILE, walk.twice.offset)),
-      `the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`,
-      DOCUMENT_WANT,
-    );
+    if (!(error instanceof StrictJSONError)) {
+      throw error;
+    }
+    throw new EdgesError(positionKey(positionAt(text, EDGES_FILE, error.offset)), error.message);
   }
-  const unknown = Object.keys(parsed).find((key) => !DOCUMENT_KEYS.has(key));
-  const description = parsed["description"];
-  const edges = parsed["edges"];
-  if (
-    unknown !== undefined ||
-    (description !== undefined && typeof description !== "string") ||
-    !Array.isArray(edges)
-  ) {
-    throw new EdgesError(
-      EDGES_FILE,
-      unknown === undefined ? EDGES_FILE : `the member ${JSON.stringify(unknown)}`,
-      DOCUMENT_WANT,
-    );
+  const value = read.value;
+  const refused = firstRefusal(EDGES_SCHEMA, value);
+  if (refused !== undefined) {
+    const place = placeIn(value, refused.pointer, refused.member);
+    const offset = place.length > 1 ? read.starts.get(place[1] ?? "") : undefined;
+    const at =
+      offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
+    const where = dotted(place);
+    throw new EdgesError(at, where === "" ? refused.reason : `${where}: ${refused.reason}`);
   }
+  const edges = (
+    value as { readonly edges: Readonly<Record<string, Record<EdgeSideName, string>>> }
+  ).edges;
 
   const sides: EdgeSide[] = [];
-  (edges as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.starts[index];
-    const at =
-      offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
-    const edge = readEdge(value, at);
-    const named: readonly [EdgeSideName, string][] = [
-      ["provides", edge.provides],
-      ["used_by", edge.usedBy],
-    ];
-    for (const [side, symbol] of named) {
-      if (symbol.startsWith(OWN_PREFIX)) {
-        sides.push({ edge: edge.id, side, symbol });
+  for (const id of read.starts.keys()) {
+    const edge = String(id);
+    for (const side of SIDE_NAMES) {
+      const symbol = edges[edge]?.[side];
+      if (symbol?.startsWith(OWN_PREFIX) === true) {
+        sides.push({ edge, side, symbol });
       }
     }
-  });
+  }
   return sides;
 }
 
@@ -190,14 +99,6 @@ interface Evaluated<F extends Finding> {
   readonly evaluations: readonly EdgeEvaluation<F>[];
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * Evaluates every declared side of this language over the run's findings. A side naming a
  * symbol the run enumerates nothing under is `absent`; otherwise it is evaluated once per
@@ -242,6 +143,6 @@ export function evaluateEdges<F extends Finding>(
       return { ...side, state: "dead", finding };
     });
   });
-  evaluations.sort((a, b) => compare(a.edge, b.edge) || compare(a.side, b.side));
+  evaluations.sort((a, b) => bytewise(a.edge, b.edge) || bytewise(a.side, b.side));
   return { findings: findings.filter((_finding, at) => !pending.has(at)), evaluations };
 }