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

package/dist/src/text/yaml.js

@@ -0,0 +1,393 @@
+/**
+ * The value of a YAML configuration document in the subset tool configurations write:
+ * block mappings and sequences, flow mappings and sequences, and plain, single-quoted and
+ * double-quoted scalars, with comments. A document using anything else, an anchor, an
+ * alias, a tag, a block scalar, a complex key or a second document, has no value here,
+ * as a JSON document that does not parse has none.
+ */
+import { isRecord } from "../json-document.js";
+/** A failure to read the document within the subset; it ends the whole reading. */
+class Unsupported extends Error {
+}
+/** The characters after which a quote opens a quoted scalar rather than standing in a plain one. */
+const SCALAR_START = new Set(["", ":", "-", "[", "{", ","]);
+/** The plain scalars YAML's core schema reads as something other than a string. */
+const CORE = new Map([
+    ["true", true],
+    ["True", true],
+    ["TRUE", true],
+    ["false", false],
+    ["False", false],
+    ["FALSE", false],
+    ["null", null],
+    ["Null", null],
+    ["NULL", null],
+    ["~", null],
+    ["", null],
+]);
+const NUMBER = /^[-+]?(?:\d+|\d*\.\d+|\d+\.\d*)(?:[eE][-+]?\d+)?$/u;
+/** The text of one line before its comment: a `#` at the line's start or after a blank, outside quotes. */
+function withoutComment(line) {
+    let quote;
+    let previous = "";
+    for (let at = 0; at < line.length; at += 1) {
+        const char = line.charAt(at);
+        if (quote !== undefined) {
+            if (quote === '"' && char === "\\") {
+                at += 1;
+            }
+            else if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if ((char === "'" || char === '"') && SCALAR_START.has(previous)) {
+            quote = char;
+        }
+        else if (char === "#" && (at === 0 || /\s/u.test(line.charAt(at - 1)))) {
+            return line.slice(0, at);
+        }
+        if (!/\s/u.test(char)) {
+            previous = char;
+        }
+    }
+    return line;
+}
+/** The value one scalar's text denotes, quoted or plain. */
+function scalar(text) {
+    const value = text.trim();
+    if (value.startsWith("'")) {
+        if (!value.endsWith("'") || value.length < 2) {
+            throw new Unsupported();
+        }
+        return value.slice(1, -1).replaceAll("''", "'");
+    }
+    if (value.startsWith('"')) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            throw new Unsupported();
+        }
+    }
+    if (/^[&*!|>%@`?]/u.test(value) || value === "---" || value === "...") {
+        throw new Unsupported();
+    }
+    if (/:(?:\s|$)/u.test(value)) {
+        throw new Unsupported();
+    }
+    if (CORE.has(value)) {
+        return CORE.get(value);
+    }
+    return NUMBER.test(value) ? Number(value) : value;
+}
+/** Reads one flow collection or flow scalar from `text` at `at`, answering the value and where it ends. */
+function flow(text, start) {
+    let at = start;
+    const skip = () => {
+        while (at < text.length && /\s/u.test(text.charAt(at))) {
+            at += 1;
+        }
+    };
+    skip();
+    const open = text.charAt(at);
+    if (open === "[" || open === "{") {
+        const close = open === "[" ? "]" : "}";
+        const items = [];
+        const object = {};
+        at += 1;
+        for (;;) {
+            skip();
+            if (text.charAt(at) === close) {
+                return { value: open === "[" ? items : object, end: at + 1 };
+            }
+            const item = flow(text, at);
+            at = item.end;
+            skip();
+            if (open === "{") {
+                if (text.charAt(at) !== ":" || typeof item.value !== "string") {
+                    throw new Unsupported();
+                }
+                const held = flow(text, at + 1);
+                object[item.value] = held.value;
+                at = held.end;
+                skip();
+            }
+            else {
+                items.push(item.value);
+            }
+            if (text.charAt(at) === ",") {
+                at += 1;
+            }
+            else if (text.charAt(at) !== close) {
+                throw new Unsupported();
+            }
+        }
+    }
+    if (open === "'" || open === '"') {
+        let end = at + 1;
+        for (; end < text.length; end += 1) {
+            const char = text.charAt(end);
+            if (open === '"' && char === "\\") {
+                end += 1;
+            }
+            else if (char === open && !(open === "'" && text.charAt(end + 1) === "'")) {
+                break;
+            }
+            else if (char === open) {
+                end += 1;
+            }
+        }
+        if (end >= text.length) {
+            throw new Unsupported();
+        }
+        return { value: scalar(text.slice(at, end + 1)), end: end + 1 };
+    }
+    let end = at;
+    while (end < text.length && !",]}".includes(text.charAt(end))) {
+        if (text.charAt(end) === ":" && /[\s,\]}]/u.test(text.charAt(end + 1) || " ")) {
+            break;
+        }
+        end += 1;
+    }
+    return { value: scalar(text.slice(at, end)), end };
+}
+/** A value written on one or more lines of a block, read whole: a flow node, else one plain scalar. */
+function flowValue(text) {
+    if (!/^["'[{]/u.test(text)) {
+        return scalar(text);
+    }
+    const read = flow(text, 0);
+    if (text.slice(read.end).trim() !== "") {
+        throw new Unsupported();
+    }
+    return read.value;
+}
+/** The position of a mapping key's `:` in one line's content, or -1 where the content is no mapping entry. */
+function keyEnd(text) {
+    let quote;
+    for (let at = 0; at < text.length; at += 1) {
+        const char = text.charAt(at);
+        if (quote !== undefined) {
+            if (quote === '"' && char === "\\") {
+                at += 1;
+            }
+            else if (char === quote) {
+                quote = undefined;
+            }
+        }
+        else if (at === 0 && (char === "'" || char === '"')) {
+            quote = char;
+        }
+        else if (char === "[" || char === "{") {
+            return -1;
+        }
+        else if (char === ":" && (at + 1 === text.length || /\s/u.test(text.charAt(at + 1)))) {
+            return at;
+        }
+    }
+    return -1;
+}
+/** How many flow collections one text opens and leaves unclosed, quotes read through. */
+function openCollections(text) {
+    let depth = 0;
+    let quote;
+    for (let at = 0; at < text.length; at += 1) {
+        const char = text.charAt(at);
+        if (quote !== undefined) {
+            if (quote === '"' && char === "\\") {
+                at += 1;
+            }
+            else if (char === quote) {
+                quote = undefined;
+            }
+        }
+        else if ((char === "'" || char === '"') &&
+            SCALAR_START.has(text.slice(0, at).trim().slice(-1))) {
+            quote = char;
+        }
+        else if (char === "[" || char === "{") {
+            depth += 1;
+        }
+        else if (char === "]" || char === "}") {
+            depth -= 1;
+        }
+    }
+    return depth;
+}
+/** Whether one line's content is a block sequence item. */
+function isItem(text) {
+    return text === "-" || text.startsWith("- ");
+}
+/** Reads the document's lines as one value. */
+class Reader {
+    at = 0;
+    lines;
+    constructor(lines) {
+        this.lines = lines;
+    }
+    /** The whole document's value. */
+    document() {
+        const first = this.lines[0];
+        if (first === undefined) {
+            return null;
+        }
+        const value = this.block(first.indent);
+        if (this.at < this.lines.length) {
+            throw new Unsupported();
+        }
+        return value;
+    }
+    /** The block node whose first line is the next one, at `indent`. */
+    block(indent) {
+        const line = this.lines[this.at];
+        if (line === undefined) {
+            return null;
+        }
+        if (isItem(line.text)) {
+            return this.sequence(indent);
+        }
+        if (keyEnd(line.text) >= 0) {
+            return this.mapping(indent);
+        }
+        return this.multiline(indent);
+    }
+    /** A scalar or a flow collection whose text runs over the next lines indented deeper than `indent`. */
+    multiline(indent) {
+        const parts = [];
+        for (let line = this.lines[this.at]; line !== undefined && (parts.length === 0 || line.indent > indent); line = this.lines[this.at]) {
+            parts.push(line.text);
+            this.at += 1;
+        }
+        return flowValue(parts.join(" "));
+    }
+    /** The value after a key or an item marker: inline text, else the deeper block below it. */
+    valueAfter(inline, indent, sequenceAtIndent) {
+        if (inline !== "") {
+            const parts = [inline];
+            // A flow collection's closing bracket may stand at the key's own column.
+            for (let line = this.lines[this.at]; line !== undefined && (line.indent > indent || openCollections(parts.join(" ")) > 0); line = this.lines[this.at]) {
+                parts.push(line.text);
+                this.at += 1;
+            }
+            return flowValue(parts.join(" "));
+        }
+        const next = this.lines[this.at];
+        if (next === undefined) {
+            return null;
+        }
+        if (next.indent > indent || (sequenceAtIndent && next.indent === indent && isItem(next.text))) {
+            return this.block(next.indent);
+        }
+        return null;
+    }
+    mapping(indent) {
+        const object = {};
+        for (let line = this.lines[this.at]; line?.indent === indent; line = this.lines[this.at]) {
+            const end = keyEnd(line.text);
+            if (end < 0) {
+                throw new Unsupported();
+            }
+            const key = scalar(line.text.slice(0, end));
+            if (typeof key === "object" && key !== null) {
+                throw new Unsupported();
+            }
+            this.at += 1;
+            object[String(key)] = this.valueAfter(line.text.slice(end + 1).trim(), indent, true);
+        }
+        const left = this.lines[this.at];
+        if (left !== undefined && left.indent > indent) {
+            throw new Unsupported();
+        }
+        return object;
+    }
+    sequence(indent) {
+        const items = [];
+        for (let line = this.lines[this.at]; line?.indent === indent && isItem(line.text); line = this.lines[this.at]) {
+            const content = line.text.slice(1);
+            const inline = content.trimStart();
+            if (inline !== "" && (isItem(inline) || keyEnd(inline) >= 0)) {
+                // A node on the item's own line continues at its own column: read it as a block there.
+                const moved = { indent: indent + 1 + content.length - inline.length, text: inline };
+                this.lines[this.at] = moved;
+                items.push(this.block(moved.indent));
+            }
+            else {
+                this.at += 1;
+                items.push(this.valueAfter(inline, indent, false));
+            }
+        }
+        const left = this.lines[this.at];
+        if (left !== undefined && left.indent > indent) {
+            throw new Unsupported();
+        }
+        return items;
+    }
+}
+/** The JSON value one YAML document's text denotes, or undefined where it lies outside the subset. */
+export function yamlDocument(text) {
+    const lines = [];
+    for (const raw of text.replace(/^\uFEFF/u, "").split(/\r?\n/u)) {
+        if (/^ *\t/u.test(raw)) {
+            return undefined;
+        }
+        const content = withoutComment(raw).trimEnd();
+        const trimmed = content.trimStart();
+        if (trimmed === "") {
+            continue;
+        }
+        if (trimmed === "---" && lines.length === 0) {
+            continue;
+        }
+        if (trimmed.startsWith("%") || trimmed === "---" || trimmed === "...") {
+            return undefined;
+        }
+        lines.push({ indent: content.length - trimmed.length, text: trimmed });
+    }
+    try {
+        return new Reader(lines).document();
+    }
+    catch (error) {
+        if (error instanceof Unsupported) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+/** The key one line of the document's top-level mapping opens, or undefined where it opens none. */
+function topLevelKey(raw) {
+    const content = withoutComment(raw).trimEnd();
+    const end = /^\s/u.test(content) ? -1 : keyEnd(content);
+    if (end < 0) {
+        return undefined;
+    }
+    try {
+        const key = scalar(content.slice(0, end));
+        return typeof key === "object" && key !== null ? undefined : String(key);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The value of one key of a document's top-level block mapping, read from that key's lines
+ * alone, so a document whose other keys lie outside the subset still yields it. A key
+ * declared twice, or one whose own lines lie outside the subset, is refused.
+ */
+export function yamlKey(text, key) {
+    const lines = text.replace(/^\uFEFF/u, "").split(/\r?\n/u);
+    const starts = lines.flatMap((line, at) => (topLevelKey(line) === undefined ? [] : [at]));
+    const named = starts.filter((at) => topLevelKey(lines[at] ?? "") === key);
+    const [start] = named;
+    if (start === undefined) {
+        return { kind: "absent" };
+    }
+    if (named.length > 1) {
+        return { kind: "refused", reason: `the ${key} key is declared more than once` };
+    }
+    const end = starts.find((at) => at > start) ?? lines.length;
+    const value = yamlDocument(lines.slice(start, end).join("\n"));
+    return isRecord(value)
+        ? { kind: "value", value: value[key] }
+        : { kind: "refused", reason: `the value of ${key} is outside the YAML subset read here` };
+}

package/dist/src/type-errors.js

@@ -1,177 +1,15 @@
 /**
- * What the errors a project's own files carry do to the run. An import of a module the
- * project expects and nothing provides is a setup failure. Any other error in an own file
- * is a type error: the function, method or file-level statement holding it is skipped,
- * which only ever withholds a finding. `projectErrors` decides, before any of these, which
- * errors the compiler places in no file leave the project unloaded.
+ * What a type error in a project's own file does: the function, method or file-level statement
+ * holding it is skipped, which only ever withholds a finding.
  */
-import { isClassDeclaration, isFunctionLikeDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
-import { packageOfSpecifier } from "./dependencies.js";
+import { isClassDeclaration, isFunctionLikeDeclaration, isPropertyAccessExpression, } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { relativePath } from "./paths.js";
 import { isAnswered } from "./query.js";
-import { findWorkspace } from "./workspace.js";
-/** The compiler's codes for an import whose module it cannot find. */
-const MODULE_NOT_FOUND = new Set([2307, 2792]);
-const MANIFEST = "package.json";
-const MANIFEST_SECTIONS = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies",
-];
 /** Whether a finding's position falls inside a skipped unit. */
 export function insideSkipped(skipped, position) {
     return skipped.some((unit) => unit.path === position.path && unit.fromLine <= position.line && position.line <= unit.toLine);
 }
-/** The string literal holding one offset, innermost first, a doc comment's included. */
-function literalAt(file, offset) {
-    let found;
-    const visit = (node) => {
-        if (offset < node.pos || offset >= node.end) {
-            return;
-        }
-        if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
-            found = node.text;
-        }
-        // `forEachChild` does not enter a doc comment, where a JavaScript file imports types.
-        for (const doc of node.jsDoc ?? []) {
-            visit(doc);
-        }
-        node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
-    return found;
-}
-/**
- * What one `paths` key's `*` matches in one specifier, `""` for a key with no `*` that
- * is the specifier, or `undefined` where the key does not match it.
- */
-function mappedBy(key, specifier) {
-    const star = key.indexOf("*");
-    if (star < 0) {
-        return key === specifier ? "" : undefined;
-    }
-    const prefix = key.slice(0, star);
-    const suffix = key.slice(star + 1);
-    return specifier.length >= prefix.length + suffix.length &&
-        specifier.startsWith(prefix) &&
-        specifier.endsWith(suffix)
-        ? specifier.slice(prefix.length, specifier.length - suffix.length)
-        : undefined;
-}
-/**
- * One `paths` target, its first `*` replaced by `star` taken literally, as the compiler does:
- * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L1282
- */
-function substituted(target, star) {
-    const at = target.indexOf("*");
-    return at < 0 ? target : target.slice(0, at) + star + target.slice(at + 1);
-}
-/**
- * Whether a path names something on disk, as written or with any extension; under
- * `fileOnly`, only a file counts.
- */
-function provided(host, path, fileOnly) {
-    const counts = (at) => fileOnly ? host.kindOf(at) === "file" : host.kindOf(at) !== "absent";
-    if (counts(path)) {
-        return true;
-    }
-    const dir = dirnamePath(path);
-    const stem = `${path.slice(dir.length + 1)}.`;
-    try {
-        return host
-            .readDirectory(dir)
-            .some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
-    }
-    catch {
-        return false;
-    }
-}
-/** The manifest at or above `dir`, no higher than the target root, that declares `name`. */
-function declaringManifest(host, dir, targetRoot, name) {
-    for (let at = dir;; at = dirnamePath(at)) {
-        const path = joinPath(at, MANIFEST);
-        let manifest;
-        try {
-            manifest = JSON.parse(host.readFile(path));
-        }
-        catch {
-            manifest = undefined;
-        }
-        if (typeof manifest === "object" && manifest !== null) {
-            const sections = manifest;
-            for (const section of MANIFEST_SECTIONS) {
-                const declared = sections[section];
-                if (typeof declared === "object" && declared !== null && Object.hasOwn(declared, name)) {
-                    return path;
-                }
-            }
-        }
-        // The target root is not below itself, so the walk stops after reading its manifest.
-        if (relativePath(targetRoot, at) === undefined) {
-            return undefined;
-        }
-    }
-}
-/**
- * Whether a package is installed for an importer in `dir`: in the `node_modules` of
- * `dir` or of any ancestor, above the target root too, as Node and the compiler look.
- */
-function installed(host, dir, name) {
-    for (let at = dir;; at = dirnamePath(at)) {
-        if (host.kindOf(joinPath(at, "node_modules", name)) === "directory") {
-            return true;
-        }
-        if (dirnamePath(at) === at) {
-            return false;
-        }
-    }
-}
-/**
- * Why one import that the compiler cannot resolve names a module the project expects,
- * with the fix, or undefined where the module is one the project does not expect.
- */
-function expectedModule(context, importer, specifier) {
-    const { host, targetRoot } = context;
-    const fix = "run the generator or the build that writes it";
-    if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
-        return provided(host, resolvePath(dirnamePath(importer), specifier), false)
-            ? undefined
-            : `which names no file of the target: ${fix}`;
-    }
-    if (specifier.startsWith("#")) {
-        return `which the manifest's imports map to no file: ${fix}`;
-    }
-    const mapped = context.paths.entries.flatMap(({ key, targets }) => {
-        const star = mappedBy(key, specifier);
-        return star === undefined
-            ? []
-            : targets.map((target) => resolvePath(context.paths.base, substituted(target, star)));
-    });
-    const name = packageOfSpecifier(specifier);
-    // The compiler looks up in `node_modules` what `paths` does not resolve, so the error
-    // of an installed package's import is the import's own, a subpath its exports omit:
-    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L548-L575
-    if (name !== undefined && installed(host, dirnamePath(importer), name)) {
-        return undefined;
-    }
-    if (mapped.length > 0) {
-        return mapped.some((path) => provided(host, path, true))
-            ? undefined
-            : `which the compiler configuration's paths map to no file: ${fix}`;
-    }
-    const manifest = name === undefined
-        ? undefined
-        : declaringManifest(host, dirnamePath(importer), targetRoot, name);
-    // No run requires a nested package that is no workspace member to be installed.
-    if (manifest === undefined ||
-        (dirnamePath(manifest) !== targetRoot && !context.member(manifest))) {
-        return undefined;
-    }
-    const where = relativePath(targetRoot, manifest) ?? manifest;
-    return `a dependency ${where} declares that is not installed: run the package manager's install`;
-}
 /**
  * The unit a type error at one offset skips: the innermost function holding it, else the
  * class member holding it where a top-level class does, else the top-level statement.
@@ -202,53 +40,13 @@ function messageOf(text, targetRoot) {
     const line = text.split(`${targetRoot}/`).join("").split(/\s+/u).join(" ").trim();
     return line === "" ? "a type error" : line;
 }
-/**
- * Reads the errors one project's own files carry. A diagnostic marking unnecessary code
- * is no error here, and one in a file that is not the project's own is that file's
- * package's to answer for.
- */
-export function readErrors(project, errors, where) {
-    let workspace = null;
-    const context = {
-        ...where,
-        member: (manifest) => {
-            if (workspace === null) {
-                workspace = findWorkspace(where.host, where.targetRoot, () => undefined);
-            }
-            return workspace?.memberOf(manifest) !== undefined;
-        },
-    };
-    const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
-    const missing = [];
-    const skips = [];
-    for (const { diagnostic, at } of errors) {
-        const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
-        if (file === undefined || diagnostic.reportsUnnecessary === true) {
-            continue;
-        }
-        const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;
-        const line = at?.line ?? 1;
-        const specifier = MODULE_NOT_FOUND.has(diagnostic.code)
-            ? literalAt(file, diagnostic.pos)
-            : undefined;
-        const expected = specifier === undefined ? undefined : expectedModule(context, file.fileName, specifier);
-        if (specifier !== undefined && expected !== undefined) {
-            missing.push({
-                setupClass: "missing-module",
-                detail: `${path}:${String(line)}: ${path} imports ${JSON.stringify(specifier)}, ${expected}`,
-            });
-            continue;
-        }
-        const unit = unitAt(file, diagnostic.pos);
-        if (unit !== undefined) {
-            skips.push({
-                record: { path, line, message: messageOf(diagnostic.text, context.targetRoot) },
-                file,
-                unit,
-            });
-        }
-    }
-    return { missing, skips };
+/** The skip one type error at `offset` of an own file makes, the root spelled relative to itself. */
+export function skipAt(file, offset, line, text, targetRoot) {
+    const unit = unitAt(file, offset);
+    const path = relativePath(targetRoot, file.fileName) ?? file.fileName;
+    return unit === undefined
+        ? undefined
+        : { record: { path, line, message: messageOf(text, targetRoot) }, file, unit };
 }
 /** The lines each skip withholds, below the target root. */
 export function skippedUnits(skips, targetRoot) {
@@ -313,22 +111,3 @@ export function skippedRoots(project, held, skips) {
     }
     return [...kept];
 }
-/** One compiler configuration's `paths` mapping, empty where it cannot be read. */
-export function pathsOf(engine, configFile) {
-    const base = dirnamePath(configFile);
-    try {
-        const { options } = engine.parseConfigFile(configFile);
-        const { paths } = options;
-        // The parse answers `pathsBasePath`, the directory of the configuration that writes
-        // `paths` (an extended one included), though the client's option type omits it:
-        // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/tsoptions/tsconfigparsing.go#L1120
-        const declaredAt = options.pathsBasePath;
-        return {
-            base: typeof declaredAt === "string" ? declaredAt : base,
-            entries: Object.entries(paths ?? {}).map(([key, targets]) => ({ key, targets })),
-        };
-    }
-    catch {
-        return { base, entries: [] };
-    }
-}