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

package/dist/src/type-errors.js

@@ -13,6 +13,12 @@ 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]);
+/**
+ * The compiler's codes for where the configuration places a file, which leave every type
+ * the file's statements carry as it is: an output that would overwrite an input (5055,
+ * 5056), a file outside `rootDir` (6059), one a composite project does not list (6307).
+ */
+const CONFIGURATION_LEVEL = new Set([5055, 5056, 6059, 6307]);
 const MANIFEST = "package.json";
 const MANIFEST_SECTIONS = [
     "dependencies",
@@ -204,8 +210,8 @@ function messageOf(text, targetRoot) {
 }
 /**
  * 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.
+ * or about where the configuration places a file 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;
@@ -223,7 +229,9 @@ export function readErrors(project, errors, where) {
     const skips = [];
     for (const { diagnostic, at } of errors) {
         const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
-        if (file === undefined || diagnostic.reportsUnnecessary === true) {
+        if (file === undefined ||
+            diagnostic.reportsUnnecessary === true ||
+            CONFIGURATION_LEVEL.has(diagnostic.code)) {
             continue;
         }
         const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;

package/dist/src/unseen-loads.js

@@ -0,0 +1,107 @@
+/**
+ * The loads of a project's production files whose target the analysis cannot resolve: an
+ * `import()` or `require()` call whose path is computed and starts with no relative literal
+ * naming a directory below the calling file's. The files such a load runs are roots the
+ * analysis does not see, so the configuration's roots are never complete.
+ */
+import { isAsExpression, isBinaryExpression, isCallExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isParenthesizedExpression, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { renderPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
+import { sourceFilesOf } from "./source-files.js";
+/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
+function unwrapped(node) {
+    let at = node;
+    while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+        at = at.expression;
+    }
+    return at;
+}
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+export function leadingLiteral(node) {
+    const at = unwrapped(node);
+    if (isTemplateExpression(at)) {
+        return at.head.text;
+    }
+    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+        const left = unwrapped(at.left);
+        return isStringLiteral(left) || isNoSubstitutionTemplateLiteral(left)
+            ? left.text
+            : leadingLiteral(at.left);
+    }
+    return undefined;
+}
+/**
+ * The directory below `dir` a computed load's leading literal names, which the entry
+ * rules root every file of, or none where it names a package, `dir` itself or a
+ * directory holding it, each of which would name files no rule roots.
+ */
+export function computedLoadDirectory(dir, prefix) {
+    if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !prefix.endsWith("/")) {
+        return undefined;
+    }
+    const target = resolvePath(dir, prefix);
+    return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
+}
+/** Whether a computed path's leading literal names a package, whose files are none of the target's. */
+function namesPackage(prefix) {
+    return (prefix !== undefined &&
+        prefix !== "" &&
+        !prefix.startsWith(".") &&
+        !prefix.startsWith("/") &&
+        !/^[A-Za-z][A-Za-z\d+.-]*:/u.test(prefix));
+}
+/**
+ * Every unresolved load the project's production files write, in file then source order.
+ * `testFiles` holds the test files by their path below the target root. A `require` call
+ * loads a module only where the name resolves to no declaration of the project's own
+ * files: one the project declares is its own function.
+ */
+export function unseenLoadsOf(project, configuration, targetRoot, testFiles) {
+    const tests = new Set(testFiles);
+    const sites = [];
+    for (const [path, file] of sourceFilesOf(project, targetRoot).byPath) {
+        if (tests.has(path) || file.isDeclarationFile) {
+            continue;
+        }
+        const dir = dirnamePath(file.fileName);
+        const visit = (node) => {
+            if (isCallExpression(node)) {
+                const callee = node.expression;
+                const required = isIdentifier(callee) && callee.text === "require";
+                const [first] = node.arguments;
+                const argument = first === undefined ? undefined : unwrapped(first);
+                if ((callee.kind === SyntaxKind.ImportKeyword || required) &&
+                    argument !== undefined &&
+                    !isStringLiteral(argument) &&
+                    !isNoSubstitutionTemplateLiteral(argument)) {
+                    const prefix = leadingLiteral(argument);
+                    const seen = namesPackage(prefix) ||
+                        (prefix !== undefined && computedLoadDirectory(dir, prefix) !== undefined);
+                    if (!seen) {
+                        sites.push({
+                            position: renderPosition(file, targetRoot, node.getStart()),
+                            require: required ? callee : undefined,
+                        });
+                    }
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    const requires = sites.flatMap((site) => (site.require === undefined ? [] : [site.require]));
+    const own = project.ownPaths();
+    const local = new Set();
+    project.symbolsAt(requires.map((node) => project.handle(node))).forEach((symbol, at) => {
+        const node = requires[at];
+        if (node !== undefined &&
+            symbol !== UNANSWERED &&
+            symbol?.declarations.some((handle) => own.has(handle.path)) === true) {
+            local.add(node);
+        }
+    });
+    return sites
+        .filter((site) => site.require === undefined || !local.has(site.require))
+        .map((site) => ({ configuration, position: site.position }));
+}

package/dist/src/verbs/analyze.js

@@ -3,7 +3,7 @@ import { ConfigError, kindOf } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { moduleIdentity } from "../consumers.js";
 import { analyzerProvenance, verdictOf } from "../findings-pass.js";
-import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
+import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { partialNotes } from "../partial.js";
 import { buildReport, LANGUAGE, capFindings, sortFindings, } from "../report.js";
 import { json } from "../reporters/json.js";
@@ -77,6 +77,24 @@ function unmappedNotes(entries, targetRoot) {
         };
     });
 }
+/**
+ * One note per load of a production file the run cannot resolve, each site once: a file
+ * it loads is a root the run does not see, so `ts.roots_complete` lifts no cap there.
+ */
+function unseenLoadNotes(loads) {
+    return [
+        ...new Map(loads.map((load) => {
+            const { path, line, column } = load.position;
+            const site = `${path}:${String(line)}:${String(column)}`;
+            const note = {
+                kind: "computed-load",
+                path: dirnamePath(path),
+                message: `${site} loads a module by a computed path the analysis cannot resolve, so the configurations compiling it report what no root reaches at probable at most, whatever ts.roots_complete says`,
+            };
+            return [site, note];
+        })).values(),
+    ];
+}
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped, targetRoot) {
     return dropped.map((one) => {
@@ -222,7 +240,11 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             typeErrorSkips: run.typeErrorSkips,
             unanswered: unansweredCounts(analysis),
             conventionsApplied: run.conventionsApplied,
-            notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+            listsComponents: config.reporters.cascade === "full",
+            notes: [
+                ...unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+                ...unseenLoadNotes(run.unseenLoads),
+            ],
         });
         report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
         verdict = verdictOf(result, config);

package/dist/src/yaml-document.js

@@ -0,0 +1,355 @@
+/**
+ * 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.
+ */
+/** 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;
+    }
+}

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.1",
+  "version": "8.0.0-dev.3",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.1",
+  "version": "8.0.0-dev.3",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",