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

package/dist/src/javascript-file.js

@@ -0,0 +1,48 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.js";
+import { globExpression } from "./text/glob.js";
+export const JAVASCRIPT_FILE = /\.(?:js|jsx|mjs|cjs)$/u;
+/** The patterns the TypeScript row of `languages.json` skips files by, each matched against a name alone. */
+const MINIFIED_NAMES = LANGUAGE_ROWS.ts.skippedFiles.map((pattern) => ({
+    pattern,
+    expression: globExpression(pattern),
+}));
+const MINIFIED_BYTES = 10_240;
+const MINIFIED_LINE = 500;
+/** What a minified file is decided by where its text is not read. */
+const LONG_LINES = "long lines";
+/** The skipped-file pattern one file's name matches, which decides it minified without its text. */
+export function minifiedByName(fileName) {
+    const name = fileName.slice(fileName.lastIndexOf("/") + 1);
+    return MINIFIED_NAMES.find((one) => one.expression.test(name))?.pattern;
+}
+/**
+ * What decides one JavaScript file minified: the skipped-file pattern its name matches, or
+ * {@link LONG_LINES} for a text of the size whose mean line is longer than the limit;
+ * undefined for a file that is not minified.
+ */
+export function minifiedBy(fileName, text) {
+    if (!JAVASCRIPT_FILE.test(fileName)) {
+        return undefined;
+    }
+    const named = minifiedByName(fileName);
+    if (named !== undefined) {
+        return named;
+    }
+    // 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 undefined;
+    }
+    const lines = text.split(/\r?\n/u).length;
+    return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE
+        ? LONG_LINES
+        : undefined;
+}
+/** The length of a text in UTF-8, a lone surrogate counting as the three bytes of U+FFFD. */
+function utf8Bytes(text) {
+    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/dist/src/json-document.js

@@ -1,106 +1,228 @@
 /**
- * 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.
  */
-/** The token walk over a document `JSON.parse` accepted, so every token is well formed. */
-class Walk {
-    starts = [];
-    /** The member written twice, where one is, as the offset of its name. */
-    twice;
-    text;
-    array;
+export class StrictJSONError extends Error {
+    offset;
+    place;
+    constructor(reason, offset, place) {
+        super(reason);
+        this.name = "StrictJSONError";
+        this.offset = offset;
+        this.place = place;
+    }
+}
+/**
+ * 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 = new Map([
+    ["true", true],
+    ["false", false],
+    ["null", null],
+]);
+/** One member name spelled as a JSON Pointer token. */
+const escaped = (name) => name.replaceAll("~", "~0").replaceAll("/", "~1");
+/** The member names and indexes a JSON Pointer holds, unescaped. */
+export function pointerSegments(pointer) {
+    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) {
+    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, pointer, member = "") {
+    const place = [];
+    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) {
+    let path = "";
+    for (const segment of place) {
+        path +=
+            typeof segment === "number" ? `[${String(segment)}]` : path === "" ? segment : `.${segment}`;
+    }
+    return path;
+}
+class Reader {
     at = 0;
-    constructor(text, array) {
+    path = [];
+    fractions = new Map();
+    starts = new Map();
+    text;
+    records;
+    constructor(text, records) {
         this.text = text;
-        this.array = array;
-    }
-    run() {
-        this.value("document");
+        this.records = records;
     }
-    skip() {
-        while (/[ \t\r\n]/u.test(this.text[this.at] ?? "")) {
-            this.at += 1;
+    read() {
+        const value = this.value(0);
+        this.match(SPACE);
+        if (this.at < this.text.length) {
+            this.fail("data follows the document's value");
         }
+        return value;
     }
-    string() {
-        const start = this.at;
-        this.at += 1;
-        while (this.text[this.at] !== '"') {
-            this.at += this.text[this.at] === "\\" ? 2 : 1;
+    fail(reason, offset = this.at, member = "") {
+        throw new StrictJSONError(reason, offset, member === "" ? [...this.path] : [...this.path, member]);
+    }
+    match(pattern) {
+        pattern.lastIndex = this.at;
+        const found = pattern.exec(this.text)?.[0];
+        this.at = found === undefined ? this.at : pattern.lastIndex;
+        return found;
+    }
+    expect(char, what) {
+        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));
     }
-    value(role) {
-        this.skip();
-        if (role === "record") {
-            this.starts.push(this.at);
+    value(depth) {
+        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);
+            return this.object(depth);
         }
-        else if (char === "[") {
-            this.list(role === "array" ? "record" : "other");
+        if (char === "[") {
+            return this.array(depth);
         }
-        else if (char === '"') {
-            this.string();
+        const string = this.match(STRING);
+        if (string !== undefined) {
+            return JSON.parse(string);
         }
-        else {
-            while (this.at < this.text.length && !/[,\]} \t\r\n]/u.test(this.text[this.at] ?? "")) {
-                this.at += 1;
+        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");
     }
-    object(role) {
-        const seen = new Set();
+    object(depth) {
+        const held = {};
         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);
+            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");
+            }
         }
     }
-    list(element) {
+    array(depth) {
+        const held = [];
+        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);
             }
-            if (this.text[this.at] === ",") {
-                this.at += 1;
+            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 (next !== ",") {
+                this.at -= 1;
+                this.fail("a comma or a closing bracket is expected");
             }
-            this.value(element);
         }
     }
 }
 /**
- * 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, array) {
-    const walk = new Walk(text, array);
-    walk.run();
-    return { starts: walk.starts, twice: walk.twice };
+export function readStrict(text, records) {
+    const reader = new Reader(text, records);
+    const value = reader.read();
+    return { value, fractions: reader.fractions, starts: reader.starts };
 }
 /**
  * One offset of a document as a finding carries it: the line counted from one, and the
@@ -111,3 +233,12 @@ export function positionAt(text, file, offset) {
     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, error) {
+    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) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/src/keyof-comparisons.js

@@ -4,11 +4,10 @@
  * that holds `keyof X`, the literal the other side has names the member of `X` under that
  * key, because deleting the member makes the comparison a type error.
  */
-import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isParenthesizedExpression, isPropertyAccessExpression, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
+import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isStringLiteral, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The operators that compare their operands for equality. */
 const EQUALITIES = new Set([
     SyntaxKind.EqualsEqualsEqualsToken,
@@ -16,12 +15,9 @@ const EQUALITIES = new Set([
     SyntaxKind.EqualsEqualsToken,
     SyntaxKind.ExclamationEqualsToken,
 ]);
-function unwrapped(node) {
-    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) {
-    const at = unwrapped(node);
+    const at = parenthesesRemoved(node);
     if (isIdentifier(at)) {
         return at;
     }
@@ -57,114 +53,137 @@ function literalNames(parts) {
     return names;
 }
 /**
- * The references the key comparisons of one project's own files make to the members their
- * literal side names, each made by the declaration holding the comparison.
+ * The reads the key comparisons of a side's files make of the members their literal side
+ * names, each made by the declaration holding the comparison. A question the checker leaves
+ * unanswered holds what its answer could have read.
  */
-export function keyofComparisonReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const comparisons = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            if (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
-                comparisons.push({ file, from: holder, keyed: node.left, other: node.right });
-                comparisons.push({ file, from: holder, keyed: node.right, other: node.left });
-            }
-            if (isSwitchStatement(node)) {
-                for (const clause of node.caseBlock.clauses) {
-                    if (isCaseClause(clause)) {
-                        comparisons.push({
-                            file,
-                            from: holder,
-                            keyed: node.expression,
-                            other: clause.expression,
+export const keyofComparisons = {
+    start() {
+        const comparisons = [];
+        return {
+            visit(node, { file, from }) {
+                if (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
+                    comparisons.push({ file, from, keyed: node.left, other: node.right });
+                    comparisons.push({ file, from, keyed: node.right, other: node.left });
+                }
+                if (isSwitchStatement(node)) {
+                    for (const clause of node.caseBlock.clauses) {
+                        if (isCaseClause(clause)) {
+                            comparisons.push({ file, from, keyed: node.expression, other: clause.expression });
+                        }
+                    }
+                }
+            },
+            reads({ project, chains }) {
+                const queries = project.queries;
+                const found = [];
+                const named = comparisons.flatMap((one) => {
+                    const name = nameOf(one.keyed);
+                    return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
+                        ? []
+                        : [{ ...one, name }];
+                });
+                if (named.length === 0) {
+                    return found;
+                }
+                // The operand's own declaration states the key type, which the checker resolves to
+                // the literals it admits and so no longer names the type the key indexes.
+                const symbols = queries.symbolsAt(named.map((one) => one.name));
+                const keyed = named.flatMap((one, at) => {
+                    const asked = symbols[at];
+                    const symbol = asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
+                        ? asked
+                        : queries.aliased(asked);
+                    if (symbol === UNANSWERED) {
+                        const text = literalText(one.other);
+                        found.push({
+                            kind: "held",
+                            from: one.from,
+                            ...(text === undefined ? {} : { names: [text] }),
                         });
+                        return [];
+                    }
+                    if (symbol === undefined) {
+                        return [];
                     }
+                    const operands = symbol.declarations.flatMap((handle) => {
+                        const declared = project.declarationAt(handle)?.node?.type;
+                        return declared === undefined ? [] : keyofOperands(declared);
+                    });
+                    return operands.length === 0 ? [] : [{ ...one, operands }];
+                });
+                if (keyed.length === 0) {
+                    return found;
                 }
-            }
-            node.forEachChild((child) => {
-                visit(child, holder);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    const named = comparisons.flatMap((one) => {
-        const name = nameOf(one.keyed);
-        return name === undefined || isElementAccessExpression(unwrapped(one.other))
-            ? []
-            : [{ ...one, name }];
-    });
-    if (named.length === 0) {
-        return [];
-    }
-    // The operand's own declaration states the key type, which the checker resolves to
-    // the literals it admits and so no longer names the type the key indexes.
-    const symbols = queries.symbolsAt(named.map((one) => one.name));
-    const keyed = named.flatMap((one, at) => {
-        const asked = symbols[at];
-        const symbol = asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
-            ? asked
-            : queries.aliased(asked);
-        if (symbol === UNANSWERED || symbol === undefined) {
-            return [];
-        }
-        const operands = symbol.declarations.flatMap((handle) => {
-            const declared = project.declarationAt(handle)?.node?.type;
-            return declared === undefined ? [] : keyofOperands(declared);
-        });
-        return operands.length === 0 ? [] : [{ ...one, operands }];
-    });
-    if (keyed.length === 0) {
-        return [];
-    }
-    const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
-    const types = queries.typesAt(nodes);
-    const typeOf = new Map();
-    nodes.forEach((node, at) => {
-        const type = types[at];
-        if (type !== UNANSWERED && type !== undefined) {
-            typeOf.set(node, type);
-        }
-    });
-    const partsOf = (type) => {
-        const parts = queries.constituents(type);
-        return parts === UNANSWERED ? [type] : parts;
-    };
-    const found = [];
-    for (const one of keyed) {
-        const literal = typeOf.get(one.other);
-        const names = literal === undefined ? [] : literalNames(partsOf(literal));
-        if (names.length === 0) {
-            continue;
-        }
-        const position = renderPosition(one.file, root, one.other.getStart());
-        for (const operand of one.operands) {
-            const object = typeOf.get(operand);
-            for (const part of object === undefined ? [] : partsOf(object)) {
-                const properties = queries.propertiesOf(part);
-                for (const property of properties === UNANSWERED ? [] : properties) {
-                    if (!names.includes(property.name)) {
-                        continue;
+                const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
+                const types = queries.typesAt(nodes);
+                const typeOf = new Map();
+                nodes.forEach((node, at) => {
+                    const type = types[at];
+                    if (type !== undefined) {
+                        typeOf.set(node, type);
                     }
-                    for (const to of chains.declarationsOf(property)) {
+                });
+                const partsOf = (type) => {
+                    const parts = queries.constituents(type);
+                    return parts === UNANSWERED ? [type] : parts;
+                };
+                for (const one of keyed) {
+                    const literal = typeOf.get(one.other);
+                    const objects = one.operands.map((operand) => typeOf.get(operand));
+                    if (literal === UNANSWERED) {
+                        const known = objects.filter((type) => type !== undefined && type !== UNANSWERED);
                         found.push({
+                            kind: "held",
                             from: one.from,
-                            to,
-                            position,
-                            use: "read",
-                            resolution: "keyed",
-                            test: testFiles.has(position.path),
+                            types: known.flatMap(partsOf),
+                            ...(known.length < objects.length ? { members: true } : {}),
                         });
+                        continue;
+                    }
+                    const names = literal === undefined ? [] : literalNames(partsOf(literal));
+                    if (names.length === 0) {
+                        continue;
+                    }
+                    for (const object of objects) {
+                        if (object === UNANSWERED) {
+                            found.push({ kind: "held", from: one.from, names });
+                            continue;
+                        }
+                        for (const part of object === undefined ? [] : partsOf(object)) {
+                            const properties = queries.propertiesOf(part);
+                            if (properties === UNANSWERED) {
+                                found.push({ kind: "held", from: one.from, names });
+                                continue;
+                            }
+                            for (const property of properties) {
+                                if (!names.includes(property.name)) {
+                                    continue;
+                                }
+                                for (const to of chains.declarationsOf(property)) {
+                                    found.push({
+                                        kind: "named",
+                                        from: one.from,
+                                        to,
+                                        file: one.file,
+                                        at: one.other,
+                                        use: "read",
+                                        via: "keyed",
+                                    });
+                                }
+                            }
+                        }
                     }
                 }
-            }
-        }
-    }
-    return found;
+                return found;
+            },
+        };
+    },
+};
+/** The text a string or number literal operand spells, where it is one. */
+function literalText(node) {
+    const at = parenthesesRemoved(node);
+    return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at)
+        ? at.text
+        : undefined;
 }