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

package/src/inventory.ts

@@ -1,4 +1,6 @@
 import {
+  isArrayBindingPattern,
+  isBindingElement,
   isClassDeclaration,
   isComputedPropertyName,
   isConstructorDeclaration,
@@ -16,6 +18,7 @@ import {
   isModuleBlock,
   isModuleDeclaration,
   isNamespaceExport,
+  isObjectBindingPattern,
   isParameterDeclaration,
   isParenthesizedTypeNode,
   isPrivateIdentifier,
@@ -28,7 +31,9 @@ import {
   isUnionTypeNode,
   isVariableStatement,
   ModifierFlags,
+  type BindingElement,
   type ClassDeclaration,
+  type Identifier,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -45,6 +50,7 @@ import {
 import { computedComponent, nameComponent, renderRef, type Component, type Module } from "./ref.ts";
 import { isAnswered, UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
+import { manifestAt } from "./fs/manifest.ts";
 
 /**
  * The symbol inventory of one project: every declaration the target's own files
@@ -168,6 +174,12 @@ export interface Inventory {
   readonly byName: ReadonlyMap<string, readonly string[]>;
   /** Each `declare module` declaration whose name is a string literal, by id, to that name. */
   readonly modules: ReadonlyMap<string, string>;
+  /**
+   * The ids of the ambient declarations: those of a declaration file, and those a `declare`
+   * modifier carries or a declaration carrying one holds. They describe code the target
+   * does not implement.
+   */
+  readonly ambient: ReadonlySet<string>;
   /**
    * Each enum member's dependents, by id: the later members of its declaration with no
    * initializer, up to the first one with an initializer, whose values its deletion moves.
@@ -222,8 +234,6 @@ interface ExportScope {
   readonly nameNode: Node;
 }
 
-const MANIFEST = "package.json";
-
 /** One manifest that names a package, and the directory below the root that holds it. */
 interface Named {
   readonly name: string;
@@ -244,24 +254,7 @@ export function packageScope(host: Host, root: string): (path: string) => Module
   const named = new Map<string, Named | undefined>();
 
   const manifestName = (dir: string): string | undefined => {
-    let text: string;
-    try {
-      text = host.readFile(joinPath(root, dir, MANIFEST));
-    } catch {
-      return undefined;
-    }
-    let value: unknown;
-    try {
-      value = JSON.parse(text);
-    } catch {
-      // A manifest this program cannot read names no package, which is the same
-      // answer as an absent one: the file is then scoped by the target root.
-      return undefined;
-    }
-    if (typeof value !== "object" || value === null) {
-      return undefined;
-    }
-    const name = (value as Record<string, unknown>)["name"];
+    const name = manifestAt(host, joinPath(root, dir))?.["name"];
     return typeof name === "string" && name !== "" ? name : undefined;
   };
 
@@ -296,6 +289,19 @@ function modifiersOf(node: Node): number {
   return (node as { readonly modifierFlags?: number }).modifierFlags ?? 0;
 }
 
+/** Whether a declaration is ambient: in a declaration file, or under a `declare` modifier. */
+function isAmbient(file: SourceFile, node: Node): boolean {
+  if (file.isDeclarationFile) {
+    return true;
+  }
+  for (let at: Node | undefined = node; at !== undefined; at = at.parent as Node | undefined) {
+    if ((modifiersOf(at) & ModifierFlags.Ambient) !== 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /** The type parameters one node declares, and none for a node that declares none. */
 function typeParametersOf(node: Node): readonly Node[] {
   if (
@@ -454,6 +460,37 @@ function visibilityOf(node: Node, name: Node | undefined): Visibility {
   return "public";
 }
 
+/**
+ * The binding elements of a destructuring declaration that each declare a name of their
+ * own, at any depth, but one with a default, whose removal skips the default's
+ * evaluation, and one beside a rest element of its object pattern, whose removal
+ * changes what the rest holds.
+ */
+function patternElements(
+  name: Node,
+): readonly { readonly element: BindingElement; readonly name: Identifier }[] {
+  if (!isObjectBindingPattern(name) && !isArrayBindingPattern(name)) {
+    return [];
+  }
+  const rest =
+    isObjectBindingPattern(name) &&
+    name.elements.some((element) => element.dotDotDotToken !== undefined);
+  return name.elements.flatMap((element) => {
+    if (
+      !isBindingElement(element) ||
+      element.initializer !== undefined ||
+      (rest && element.dotDotDotToken === undefined)
+    ) {
+      return [];
+    }
+    const bound = element.name;
+    if (bound === undefined) {
+      return [];
+    }
+    return isIdentifier(bound) ? [{ element, name: bound }] : patternElements(bound);
+  });
+}
+
 /** The name node of one declaration, for the kinds that carry one. */
 function nameNodeOf(node: Node): Node | undefined {
   return (node as { readonly name?: Node }).name;
@@ -781,15 +818,19 @@ export function inventory<Brand>(
     if (isVariableStatement(node)) {
       for (const declaration of node.declarationList.declarations) {
         const component = componentOf(declaration.name);
-        if (component === undefined) {
-          // A destructuring pattern declares binding elements, which the reference
-          // grammar does not represent; the statement stands for them.
+        if (component !== undefined) {
+          declare(declaration, owner, "variable", declaration.name, {
+            component,
+            localName: undefined,
+          });
           continue;
         }
-        declare(declaration, owner, "variable", declaration.name, {
-          component,
-          localName: undefined,
-        });
+        for (const { element, name } of patternElements(declaration.name)) {
+          declare(element, owner, "variable", name, {
+            component: { text: name.text, computed: false },
+            localName: undefined,
+          });
+        }
       }
       return;
     }
@@ -1067,6 +1108,11 @@ export function inventory<Brand>(
       .map((symbol) => symbol.id),
     byName: namesOf(building),
     modules: new Map(modules.map(([record, name]) => [positionKey(record.position), name])),
+    ambient: new Set(
+      building
+        .filter((record) => isAmbient(record.file, record.node))
+        .map((record) => positionKey(record.position)),
+    ),
     dependents,
   };
 }

package/src/javascript-file.ts

@@ -0,0 +1,37 @@
+export const JAVASCRIPT_FILE = /\.(?:js|jsx|mjs|cjs)$/u;
+
+/** A minified file by its name; any other is one by its size and its mean line length. */
+const MINIFIED_NAME = /\.min\.(?:js|mjs|cjs)$/u;
+const MINIFIED_BYTES = 10_240;
+const MINIFIED_LINE = 500;
+
+/** Whether one name is a minified file's, which decides it without its text. */
+export function minifiedByName(fileName: string): boolean {
+  return MINIFIED_NAME.test(fileName);
+}
+
+/** Whether one JavaScript file is minified: by its name, or by its text's size and mean line length. */
+export function minified(fileName: string, text: string): boolean {
+  if (!JAVASCRIPT_FILE.test(fileName)) {
+    return false;
+  }
+  if (minifiedByName(fileName)) {
+    return true;
+  }
+  // A UTF-16 unit encodes to at most three UTF-8 bytes, so a shorter text is below the size.
+  if (text.length * 3 < MINIFIED_BYTES) {
+    return false;
+  }
+  const lines = text.split(/\r?\n/u).length;
+  return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE;
+}
+
+/** The length of a text in UTF-8, a lone surrogate counting as the three bytes of U+FFFD. */
+function utf8Bytes(text: string): number {
+  let bytes = 0;
+  for (const character of text) {
+    const point = character.codePointAt(0) ?? 0;
+    bytes += point < 0x80 ? 1 : point < 0x800 ? 2 : point < 0x10000 ? 3 : 4;
+  }
+  return bytes;
+}

package/src/json-document.ts

@@ -1,122 +1,276 @@
+import type { Position } from "./position.ts";
+
+/** A place inside a document: each member name a string, each array index a number. */
+export type Place = readonly (string | number)[];
+
 /**
- * A read of a strict JSON document beside its parse: what a parse into a value cannot
- * report, the offset of each record of one array and a member written twice.
+ * A text that is not one strict JSON document: a syntax error, data after the value, a
+ * member one object writes twice, or nesting past {@link MAX_DEPTH}. `place` is the
+ * value the fault is in, followed by the member written twice.
  */
+export class StrictJSONError extends Error {
+  readonly offset: number;
+  readonly place: Place;
 
-import type { Position } from "./position.ts";
+  constructor(reason: string, offset: number, place: Place) {
+    super(reason);
+    this.name = "StrictJSONError";
+    this.offset = offset;
+    this.place = place;
+  }
+}
 
-/** The token walk over a document `JSON.parse` accepted, so every token is well formed. */
-class Walk {
-  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;
-  private readonly array: string;
+/** One strict JSON document, read whole. */
+interface StrictDocument {
+  readonly value: unknown;
+  /**
+   * The text of every number written with a fraction or an exponent, by its JSON
+   * Pointer: a value reads `100.0` as the integer 100, so only the text tells them apart.
+   */
+  readonly fractions: ReadonlyMap<string, string>;
+  /**
+   * The offset of each value inside the top-level member a read names, by its index or
+   * its member name, in document order.
+   */
+  readonly starts: ReadonlyMap<string | number, number>;
+}
+
+/**
+ * How deep values may nest. A document this analyzer reads nests a few levels, and a
+ * bound turns a document built to exhaust the stack into a refusal.
+ */
+const MAX_DEPTH = 1000;
+
+const SPACE = /[ \t\n\r]*/uy;
+const STRING =
+  /"(?:[ !#$%&'()*+,\-./0-9:;<=>?@A-Z[\]-\u{10FFFF}]|\\(?:["\\/bfnrt]|u[0-9A-Fa-f]{4}))*"/uy;
+const NUMBER = /-?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/uy;
+const LITERALS: ReadonlyMap<string, unknown> = new Map<string, unknown>([
+  ["true", true],
+  ["false", false],
+  ["null", null],
+]);
+
+/** One member name spelled as a JSON Pointer token. */
+const escaped = (name: string): string => name.replaceAll("~", "~0").replaceAll("/", "~1");
+
+/** The member names and indexes a JSON Pointer holds, unescaped. */
+export function pointerSegments(pointer: string): string[] {
+  return pointer === ""
+    ? []
+    : pointer
+        .slice(1)
+        .split("/")
+        .map((token) => token.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+
+/** The JSON Pointer of a place written as segments. */
+export function pointerOf(segments: readonly string[]): string {
+  return segments.map((segment) => `/${escaped(segment)}`).join("");
+}
+
+/**
+ * The place a JSON Pointer names inside `value`, followed by `member` where it is not
+ * empty: a pointer's text does not say whether a segment of digits is an index, so the
+ * value it points into does.
+ */
+export function placeIn(value: unknown, pointer: string, member = ""): (string | number)[] {
+  const place: (string | number)[] = [];
+  let held = value;
+  for (const segment of pointerSegments(pointer)) {
+    if (Array.isArray(held)) {
+      place.push(Number(segment));
+      held = held[Number(segment)];
+    } else {
+      place.push(segment);
+      held = isRecord(held) ? held[segment] : undefined;
+    }
+  }
+  return member === "" ? place : [...place, member];
+}
+
+/**
+ * A place as a refusal names it: member names joined by full stops and an index in
+ * square brackets, as `ts.serializers[0].returns`.
+ */
+export function dotted(place: Place): string {
+  let path = "";
+  for (const segment of place) {
+    path +=
+      typeof segment === "number" ? `[${String(segment)}]` : path === "" ? segment : `.${segment}`;
+  }
+  return path;
+}
+
+class Reader {
   private at = 0;
+  private readonly path: (string | number)[] = [];
+  readonly fractions = new Map<string, string>();
+  readonly starts = new Map<string | number, number>();
+  private readonly text: string;
+  private readonly records: string | undefined;
 
-  constructor(text: string, array: string) {
+  constructor(text: string, records: string | undefined) {
     this.text = text;
-    this.array = array;
+    this.records = records;
   }
 
-  run(): void {
-    this.value("document");
+  read(): unknown {
+    const value = this.value(0);
+    this.match(SPACE);
+    if (this.at < this.text.length) {
+      this.fail("data follows the document's value");
+    }
+    return value;
   }
 
-  private skip(): void {
-    while (/[ \t\r\n]/u.test(this.text[this.at] ?? "")) {
-      this.at += 1;
-    }
+  private fail(reason: string, offset = this.at, member = ""): never {
+    throw new StrictJSONError(
+      reason,
+      offset,
+      member === "" ? [...this.path] : [...this.path, member],
+    );
   }
 
-  private string(): string {
-    const start = this.at;
-    this.at += 1;
-    while (this.text[this.at] !== '"') {
-      this.at += this.text[this.at] === "\\" ? 2 : 1;
+  private match(pattern: RegExp): string | undefined {
+    pattern.lastIndex = this.at;
+    const found = pattern.exec(this.text)?.[0];
+    this.at = found === undefined ? this.at : pattern.lastIndex;
+    return found;
+  }
+
+  private expect(char: string, what: string): void {
+    this.match(SPACE);
+    if (this.text[this.at] !== char) {
+      this.fail(`${what} is expected`);
     }
     this.at += 1;
-    return JSON.parse(this.text.slice(start, this.at)) as string;
   }
 
-  private value(role: "document" | "array" | "record" | "other"): void {
-    this.skip();
-    if (role === "record") {
-      this.starts.push(this.at);
+  private value(depth: number): unknown {
+    this.match(SPACE);
+    if (depth > MAX_DEPTH) {
+      this.fail(`values nest deeper than ${String(MAX_DEPTH)} levels`);
     }
     const char = this.text[this.at];
     if (char === "{") {
-      this.object(role);
-    } else if (char === "[") {
-      this.list(role === "array" ? "record" : "other");
-    } else if (char === '"') {
-      this.string();
-    } else {
-      while (this.at < this.text.length && !/[,\]} \t\r\n]/u.test(this.text[this.at] ?? "")) {
-        this.at += 1;
+      return this.object(depth);
+    }
+    if (char === "[") {
+      return this.array(depth);
+    }
+    const string = this.match(STRING);
+    if (string !== undefined) {
+      return JSON.parse(string) as string;
+    }
+    NUMBER.lastIndex = this.at;
+    const number = NUMBER.exec(this.text);
+    if (number !== null) {
+      this.at = NUMBER.lastIndex;
+      if (number[1] !== undefined || number[2] !== undefined) {
+        this.fractions.set(pointerOf(this.path.map(String)), number[0]);
       }
+      return Number(number[0]);
     }
+    for (const [literal, held] of LITERALS) {
+      if (this.text.startsWith(literal, this.at)) {
+        this.at += literal.length;
+        return held;
+      }
+    }
+    return this.fail(
+      char === undefined ? "the document ends where a value is expected" : "a value is expected",
+    );
   }
 
-  private object(role: string): void {
-    const seen = new Set<string>();
+  private object(depth: number): Record<string, unknown> {
+    const held: Record<string, unknown> = {};
     this.at += 1;
+    this.match(SPACE);
+    if (this.text[this.at] === "}") {
+      this.at += 1;
+      return held;
+    }
     for (;;) {
-      this.skip();
-      if (this.text[this.at] === "}") {
-        this.at += 1;
-        return;
+      this.match(SPACE);
+      const offset = this.at;
+      const spelled = this.match(STRING);
+      if (spelled === undefined) {
+        return this.fail("a member name is expected");
       }
-      if (this.text[this.at] === ",") {
-        this.at += 1;
-        this.skip();
+      const name = JSON.parse(spelled) as string;
+      if (Object.hasOwn(held, name)) {
+        this.fail(
+          `the member ${JSON.stringify(name)} is written twice, so neither value is chosen`,
+          offset,
+          name,
+        );
       }
-      const offset = this.at;
-      const name = this.string();
-      if (seen.has(name) && this.twice === undefined) {
-        this.twice = { name, offset };
+      this.expect(":", "a colon after the member name");
+      if (depth === 1 && this.path[0] === this.records) {
+        this.match(SPACE);
+        this.starts.set(name, this.at);
       }
-      seen.add(name);
-      this.skip();
+      this.path.push(name);
+      Object.defineProperty(held, name, {
+        value: this.value(depth + 1),
+        enumerable: true,
+        writable: true,
+        configurable: true,
+      });
+      this.path.pop();
+      this.match(SPACE);
+      const next = this.text[this.at];
       this.at += 1;
-      this.value(role === "document" && name === this.array ? "array" : "other");
+      if (next === "}") {
+        return held;
+      }
+      if (next !== ",") {
+        this.at -= 1;
+        this.fail("a comma or a closing brace is expected");
+      }
     }
   }
 
-  private list(element: "record" | "other"): void {
+  private array(depth: number): unknown[] {
+    const held: unknown[] = [];
+    const records = depth === 1 && this.path[0] === this.records;
     this.at += 1;
+    this.match(SPACE);
+    if (this.text[this.at] === "]") {
+      this.at += 1;
+      return held;
+    }
     for (;;) {
-      this.skip();
-      if (this.text[this.at] === "]") {
-        this.at += 1;
-        return;
+      this.match(SPACE);
+      if (records) {
+        this.starts.set(held.length, this.at);
+      }
+      this.path.push(held.length);
+      held.push(this.value(depth + 1));
+      this.path.pop();
+      this.match(SPACE);
+      const next = this.text[this.at];
+      this.at += 1;
+      if (next === "]") {
+        return held;
       }
-      if (this.text[this.at] === ",") {
-        this.at += 1;
+      if (next !== ",") {
+        this.at -= 1;
+        this.fail("a comma or a closing bracket is expected");
       }
-      this.value(element);
     }
   }
 }
 
-/** What a walk of one document found. */
-interface DocumentWalk {
-  /** 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;
-}
-
 /**
- * Walks a document `JSON.parse` accepted, whose top-level member `array` holds the
- * records. A member one object writes twice reads as though it were written once, its
- * later value silently replacing the earlier one, so a document holding one is one a
- * reader names rather than reads.
+ * Reads `text` as one strict JSON document, or throws a {@link StrictJSONError}.
+ * `records` names the top-level member whose values' offsets the read keeps.
  */
-export function walkDocument(text: string, array: string): DocumentWalk {
-  const walk = new Walk(text, array);
-  walk.run();
-  return { starts: walk.starts, twice: walk.twice };
+export function readStrict(text: string, records?: string): StrictDocument {
+  const reader = new Reader(text, records);
+  const value = reader.read();
+  return { value, fractions: reader.fractions, starts: reader.starts };
 }
 
 /**
@@ -128,3 +282,14 @@ export function positionAt(text: string, file: string, offset: number): Position
   const lineStart = before.lastIndexOf("\n") + 1;
   return { path: file, line: before.split("\n").length, column: offset - lineStart + 1 };
 }
+
+/** A strict read's fault with the line and column it is at, as a refusal states it. */
+export function locatedFault(text: string, error: StrictJSONError): string {
+  const { line, column } = positionAt(text, "", error.offset);
+  return `line ${String(line)}, column ${String(column)}: ${error.message}`;
+}
+
+/** Whether a decoded JSON value is an object: not `null` and not an array. */
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/keyof-comparisons.ts

@@ -10,7 +10,6 @@ import {
   isCaseClause,
   isElementAccessExpression,
   isIdentifier,
-  isParenthesizedExpression,
   isPropertyAccessExpression,
   isSwitchStatement,
   isTypeOperatorNode,
@@ -27,6 +26,7 @@ import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
 
 /** The operators that compare their operands for equality. */
 const EQUALITIES: ReadonlySet<SyntaxKind> = new Set([
@@ -44,13 +44,9 @@ interface Comparison {
   readonly other: Expression;
 }
 
-function unwrapped(node: Expression): Expression {
-  return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
-
 /** The name node an operand's symbol is read at: an identifier, or a property access's name. */
 function nameOf(node: Expression): Node | undefined {
-  const at = unwrapped(node);
+  const at = parenthesesRemoved(node);
   if (isIdentifier(at)) {
     return at;
   }
@@ -132,7 +128,7 @@ export function keyofComparisonReferences<Brand>(
   }
   const named = comparisons.flatMap((one) => {
     const name = nameOf(one.keyed);
-    return name === undefined || isElementAccessExpression(unwrapped(one.other))
+    return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
       ? []
       : [{ ...one, name }];
   });