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

package/dist/src/roots/unseen-loads.js

@@ -0,0 +1,236 @@
+/**
+ * The loads by a computed path: those whose files the analysis resolves, and those it
+ * cannot, whose files are roots the analysis does not see, so the configuration's roots
+ * are never complete.
+ */
+import { isBinaryExpression, isCallExpression, isIdentifier, isMetaProperty, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { amdLoadOf, amdUnresolved } from "../amd.js";
+import { membersNamed, textsOf, writtenValue } from "../entries/static-module.js";
+import { writtenName } from "../platform-calls.js";
+import { cannotStartPackageName, dirnamePath, hasURLScheme, isAbsolutePath, relativePath, resolvePath, startsRelativePath, } from "../paths.js";
+import { unwrapped } from "../unwrap.js";
+import { globExpression } from "../text/glob.js";
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+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, every file of which
+ * the load reaches, or none where it names a package, `dir` itself or a directory holding
+ * it, each of which would name every sibling.
+ */
+function computedLoadDirectory(dir, prefix) {
+    if (!startsRelativePath(prefix) || !prefix.endsWith("/")) {
+        return undefined;
+    }
+    const target = resolvePath(dir, prefix);
+    return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
+}
+/** Whether one node is a call that may load a module by a computed path. */
+export function isLoadCall(node) {
+    if (!isCallExpression(node)) {
+        return false;
+    }
+    return (node.expression.kind === SyntaxKind.ImportKeyword ||
+        writtenName(node.expression) !== undefined ||
+        isMetaGlob(node));
+}
+/**
+ * The files one `import.meta.glob` call loads, as Vite's `toAbsoluteGlob` reads its globs
+ * (https://vite.dev/guide/features.html#glob-import): `/` against the project root, `./`
+ * and `../` against a literal `base` (read against the root where it starts with `/`) or the
+ * calling file's directory, `**` as written, and `!` removing what it matches. Undefined
+ * where Vite reads a glob through an alias, the root is unknown, or a glob or base is computed.
+ */
+function globbed(file, first, options, others, rootOf) {
+    const patterns = textsOf(writtenValue(first), true);
+    const bases = globOption(options, "base");
+    const [written, ...more] = bases ?? [];
+    const base = written === undefined ? undefined : textsOf(written, false);
+    if (patterns === undefined ||
+        bases === undefined ||
+        more.length > 0 ||
+        (written !== undefined && base === undefined)) {
+        return undefined;
+    }
+    const dir = dirnamePath(file.fileName);
+    const root = () => rootOf(file.fileName);
+    const against = (at) => {
+        if (!isAbsolutePath(at)) {
+            return resolvePath(dir, at);
+        }
+        const top = root();
+        return top === undefined ? undefined : resolvePath(top, `.${at}`);
+    };
+    const from = base?.[0] === undefined ? dir : against(base[0]);
+    const keep = [];
+    const drop = [];
+    for (const written of patterns) {
+        const negated = written.startsWith("!");
+        const pattern = negated ? written.slice(1) : written;
+        let path;
+        if (isAbsolutePath(pattern)) {
+            path = against(pattern);
+        }
+        else if (startsRelativePath(pattern)) {
+            path = from === undefined ? undefined : resolvePath(from, pattern);
+        }
+        else if (pattern.startsWith("**")) {
+            path = pattern;
+        }
+        if (path === undefined) {
+            return undefined;
+        }
+        (negated ? drop : keep).push(globExpression(path));
+    }
+    return others.filter((candidate) => keep.some((glob) => glob.test(candidate.file.fileName)) &&
+        !drop.some((glob) => glob.test(candidate.file.fileName)));
+}
+/**
+ * The computed loads among one file's load calls, each loading the `candidates` but the
+ * file itself: an `import()` or `require()` whose path starts with a relative literal naming
+ * a directory below the file's loads every candidate below it, as a bundler's context module
+ * reads it, and an `import.meta.glob` every candidate its globs match ({@link globbed}). A
+ * call of a computed path that names no such directory and no package is an unresolved load,
+ * and so is an AMD call one of whose dependencies names no path ({@link amdUnresolved}).
+ */
+export function computedLoadsOf(file, calls, candidates, rootOf) {
+    const dir = dirnamePath(file.fileName);
+    const others = candidates.filter((candidate) => candidate.file !== file);
+    return calls.flatMap(({ call, from }) => {
+        const [first, options] = call.arguments;
+        if (first === undefined) {
+            return [];
+        }
+        if (isMetaGlob(call)) {
+            const files = globbed(file, first, options, others, rootOf);
+            const asset = readsAsAsset(options);
+            return [
+                {
+                    call,
+                    from,
+                    require: undefined,
+                    amd: false,
+                    files: files ?? [],
+                    resolved: files !== undefined,
+                    asset,
+                    eager: isEager(options),
+                },
+            ];
+        }
+        const amd = amdLoadOf(call);
+        if (amd !== undefined) {
+            return amdUnresolved(amd)
+                ? [
+                    {
+                        call,
+                        from,
+                        require: amd.callee,
+                        amd: true,
+                        files: [],
+                        resolved: false,
+                        asset: false,
+                        eager: false,
+                    },
+                ]
+                : [];
+        }
+        const argument = unwrapped(first);
+        const require = call.expression.kind === SyntaxKind.ImportKeyword ? undefined : writtenName(call.expression);
+        if (!mayNamePath(argument)) {
+            return [];
+        }
+        const prefix = leadingLiteral(argument);
+        if (namesPackage(prefix)) {
+            return [];
+        }
+        const target = prefix === undefined ? undefined : computedLoadDirectory(dir, prefix);
+        const files = target === undefined
+            ? []
+            : others.filter((candidate) => relativePath(target, candidate.file.fileName) !== undefined);
+        return [
+            {
+                call,
+                from,
+                require,
+                amd: false,
+                files,
+                resolved: target !== undefined,
+                asset: false,
+                eager: false,
+            },
+        ];
+    });
+}
+/**
+ * Whether a computed argument may be a module path: anything but a string, which names its
+ * module, and a value no path is, a number, a boolean, `null`, an object, an array, a
+ * function or a class.
+ */
+function mayNamePath(argument) {
+    return !NO_PATH.has(argument.kind);
+}
+const NO_PATH = new Set([
+    SyntaxKind.StringLiteral,
+    SyntaxKind.NoSubstitutionTemplateLiteral,
+    SyntaxKind.NumericLiteral,
+    SyntaxKind.BigIntLiteral,
+    SyntaxKind.TrueKeyword,
+    SyntaxKind.FalseKeyword,
+    SyntaxKind.NullKeyword,
+    SyntaxKind.ObjectLiteralExpression,
+    SyntaxKind.ArrayLiteralExpression,
+    SyntaxKind.ArrowFunction,
+    SyntaxKind.FunctionExpression,
+    SyntaxKind.ClassExpression,
+    SyntaxKind.RegularExpressionLiteral,
+]);
+/** Whether one call is `import.meta.glob(...)`. */
+function isMetaGlob(node) {
+    if (!isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const { expression, name } = node.expression;
+    return (isIdentifier(name) &&
+        name.text === "glob" &&
+        isMetaProperty(expression) &&
+        expression.keywordToken === SyntaxKind.ImportKeyword);
+}
+/** The values the options of an `import.meta.glob` write for one key, undefined where a spread may hide one. */
+function globOption(options, key) {
+    return options === undefined ? [] : membersNamed(writtenValue(options), key);
+}
+/** Whether the options of an `import.meta.glob` set `eager` to `true`. */
+function isEager(options) {
+    return (globOption(options, "eager")?.some((value) => value.kind === "boolean" && value.value) === true);
+}
+/** The query parameters that make Vite load a file as its text or its URL, each written bare. */
+const ASSET_QUERY = /(?:^\?|&)(?:raw|url|inline)(?:&|$)/u;
+/**
+ * Whether the options of an `import.meta.glob` read each file as text or as a URL: a
+ * `query` string holding a bare `raw`, `url` or `inline`, or an `as` of `raw` or `url`,
+ * which Vite reads as that query (https://vite.dev/guide/features.html#glob-import). Any
+ * other query is read as loading the module, which keeps more than it may.
+ */
+function readsAsAsset(options) {
+    const texts = (key) => (globOption(options, key) ?? []).flatMap((value) => value.kind === "text" ? [value.text] : []);
+    return (texts("as").some((text) => text === "raw" || text === "url") ||
+        texts("query").some((text) => ASSET_QUERY.test(text.startsWith("?") ? text : `?${text}`)));
+}
+/** 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 !== "" &&
+        !cannotStartPackageName(prefix) &&
+        !hasURLScheme(prefix));
+}

package/dist/src/run.js

@@ -1,8 +1,12 @@
-import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
-import { DiscoveryError, renderDiagnostic } from "./discover.js";
+import { CONFIG_MAX_BYTES, SETTINGS } from "./contract/config.generated.js";
+import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.js";
+import { REPOSITORY_DOCUMENT } from "./config.js";
+import { readTargetDocument } from "./fs/document.js";
 import { joinPath, resolvePath } from "./paths.js";
-import { readScope, ScopeError, scopeForDir } from "./scope.js";
-import { SetupError, setupLine } from "./setup-failure.js";
+import { renderDiagnostic } from "./load/diagnostics.js";
+import { FailureExit, failureLines, productFault } from "./failure.js";
+import { readScope, scopeForDir } from "./scope.js";
+import { UsageError } from "./usage.js";
 import { openEngine } from "./session.js";
 import { printConfigVerb } from "./verbs/print-config.js";
 import { printProjectsVerb } from "./verbs/print-projects.js";
@@ -11,8 +15,9 @@ import { printRootsVerb } from "./verbs/print-roots.js";
 import { ANALYZE_OPTIONS, analyzeVerb } from "./verbs/analyze.js";
 import { describeVerb } from "./verbs/describe.js";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.js";
-import { EXIT_FAILURE, EXIT_USAGE } from "./verbs/verb.js";
+import {} from "./verbs/verb.js";
 import { versionVerb } from "./verbs/version.js";
+import { diagnose, message, PRODUCT } from "./product.js";
 /** Every verb this command answers, in the order the usage text lists them. */
 const VERBS = [
     { name: "analyze", run: analyzeVerb, options: ANALYZE_OPTIONS },
@@ -24,7 +29,7 @@ const VERBS = [
     { name: "describe", run: describeVerb },
     { name: "version", run: versionVerb },
 ];
-const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
+const USAGE = `usage: ${PRODUCT} <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
 /**
  * The tokens whose presence in an option's name makes that option a request to
  * edit a source file. The set is closed, and a token is matched in any position of
@@ -32,29 +37,12 @@ const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) =>
  */
 const SOURCE_EDIT_TOKENS = ["fix", "edit", "delete", "rewrite"];
 /**
- * Maps an option name to the setting of the Contract's configuration schema it supplies,
- * so one entry registers the option, supplies the document resolution reads, and gives
- * the spelling the setting's provenance names. The name is this command's vocabulary and
- * is never derived from the path: a setting reaches the command line only by an entry,
- * and a path names a key the schema declares.
+ * Maps an option name to the setting of the Contract's configuration schema it supplies:
+ * the options contract/settings.json names for a setting this analyzer reads.
  */
-export const SETTING_OPTIONS = new Map([
-    ["min-confidence", "analysis.min_confidence"],
-    ["sort", "reporters.sort"],
-    ["cascade", "reporters.cascade"],
-    ["max-findings", "reporters.max_findings"],
-    ["fail-on", "reporters.fail_on"],
-]);
+export const SETTING_OPTIONS = new Map(SETTINGS.flatMap((row) => (row.option === undefined ? [] : [[row.option, row.key]])));
 /** The options that take a value and are not settings. */
 const PLAIN_OPTIONS = new Set(["target", "config", "central", "scope"]);
-/**
- * The setting options whose value is an integer rather than a string. A value
- * written other than as digits is passed on as the string it is, so resolution
- * refuses it by its type rather than reading `1e2` as 100.
- */
-const INTEGER_OPTIONS = new Set(["max-findings"]);
-/** An integer as an option writes it: an optional minus sign and digits alone. */
-const INTEGER_TEXT = /^-?[0-9]+$/u;
 /** No option beyond the ones every verb takes. */
 const NO_OPTIONS = { plain: [], repeatable: [] };
 /**
@@ -81,7 +69,7 @@ function readOptions(args, own) {
     const repeated = new Map();
     for (const arg of args) {
         if (!arg.startsWith("-")) {
-            throw new ConfigError("malformed", "", `unexpected argument ${JSON.stringify(arg)}`);
+            throw new UsageError(`unexpected argument ${JSON.stringify(arg)}`);
         }
         const [spelled, ...rest] = arg.split("=");
         const name = (spelled ?? "").replace(/^-+/u, "");
@@ -89,10 +77,10 @@ function readOptions(args, own) {
             !SETTING_OPTIONS.has(name) &&
             !own.plain.includes(name) &&
             !own.repeatable.includes(name)) {
-            throw new ConfigError("malformed", "", `unknown option ${JSON.stringify(spelled ?? arg)}`);
+            throw new UsageError(`unknown option ${JSON.stringify(spelled ?? arg)}`);
         }
         if (rest.length === 0) {
-            throw new ConfigError("malformed", "", `option ${JSON.stringify(spelled ?? arg)} takes a value`);
+            throw new UsageError(`option ${JSON.stringify(spelled ?? arg)} takes a value`);
         }
         const value = rest.join("=");
         named.set(name, value);
@@ -100,45 +88,49 @@ function readOptions(args, own) {
     }
     return { named, repeated };
 }
-function readFileOr(host, path, orUndefined) {
+/** The document an option names. */
+function documentAt(host, label) {
     try {
-        return host.readFile(resolvePath(host.workingDirectory(), path));
+        const path = resolvePath(host.workingDirectory(), label);
+        // A file past the bound reads as one byte more than it, which resolution refuses.
+        return { text: host.readFile(path, CONFIG_MAX_BYTES + 1), label };
     }
     catch (error) {
-        if (orUndefined) {
-            return undefined;
-        }
-        throw new ConfigError("malformed", "", `${path}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new UsageError(`${label}: ${message(error)}`);
     }
 }
 /**
- * The configuration documents one invocation reads: the repository configuration
- * at the target root or the path an option named, the central configuration, and
- * the settings the options supply as one flag document.
+ * The repository configuration at the target root, none where it is absent. One that
+ * cannot be read is a configuration document that cannot be, refused with the usage code.
+ */
+function repositoryAt(host, target) {
+    const label = joinPath(target, REPOSITORY_DOCUMENT);
+    const root = resolvePath(host.workingDirectory(), target);
+    const text = readTargetDocument(host, root, REPOSITORY_DOCUMENT, label, (named, reason) => new UsageError(`${named}: ${reason}`));
+    return text === undefined ? undefined : { text, label };
+}
+/**
+ * The configuration sources one invocation carries: the repository configuration at
+ * the target root or the path an option named, the central configuration, and the
+ * text each setting option was given.
  */
 function inputsOf(host, options) {
-    const target = options.named.get("target") ?? ".";
     const named = options.named.get("config");
-    const repositoryLabel = named ?? joinPath(target, REPOSITORY_DOCUMENT);
-    const repository = readFileOr(host, repositoryLabel, named === undefined);
+    const target = options.named.get("target") ?? ".";
+    const repository = named === undefined ? repositoryAt(host, target) : documentAt(host, named);
     const centralLabel = options.named.get("central");
-    const central = centralLabel === undefined ? undefined : readFileOr(host, centralLabel, false);
-    const flat = {};
-    const flagLabels = new Map();
-    for (const [name, path] of SETTING_OPTIONS) {
+    const central = centralLabel === undefined ? undefined : documentAt(host, centralLabel);
+    const flags = new Map();
+    for (const [name, key] of SETTING_OPTIONS) {
         const value = options.named.get(name);
-        if (value === undefined) {
-            continue;
+        if (value !== undefined) {
+            flags.set(key, value);
         }
-        flat[path] = INTEGER_OPTIONS.has(name) && INTEGER_TEXT.test(value) ? Number(value) : value;
-        flagLabels.set(path, `--${name}`);
     }
-    const flags = Object.keys(flat).length === 0 ? undefined : JSON.stringify(flat);
     return {
-        ...(flags === undefined ? {} : { flags }),
-        ...(repository === undefined ? {} : { repository, repositoryLabel }),
-        ...(central === undefined || centralLabel === undefined ? {} : { central, centralLabel }),
-        flagLabels,
+        flags,
+        ...(repository === undefined ? {} : { repository }),
+        ...(central === undefined ? {} : { central }),
     };
 }
 /** The scope one invocation analyzes: the document an option named, or the target. */
@@ -154,14 +146,12 @@ function scopeOf(host, options) {
  * the exit code: 0 for a completed verb, 1 for a finding that fails the run, 2 for a
  * usage error, a requested source edit or a refused configuration, 3 for a failure that
  * produced no answer. It writes nothing outside `out` and `err` and never exits the
- * process. `host` is the platform the run reads, the version it reports included, and
- * `openClient` opens the compiler client; a caller that watches what a run reads
- * supplies its own of either.
+ * process. A caller that watches what a run reads supplies its own `host` or `openClient`.
  */
 export function run(args, out, err, host, openClient = openEngine) {
     const editing = sourceEditOption(args);
     if (editing !== undefined) {
-        err.write(`deadset-ts: ${editing} is not supported: deadset-ts reports and never edits a source file\n`);
+        diagnose(err, `${editing} is not supported: ${PRODUCT} reports and never edits a source file`);
         err.write(USAGE);
         return EXIT_USAGE;
     }
@@ -171,7 +161,7 @@ export function run(args, out, err, host, openClient = openEngine) {
         return invoke(verb.run, verb.options ?? NO_OPTIONS, args.slice(1), { out, err, host }, openClient);
     }
     if (name !== undefined) {
-        err.write(`deadset-ts: unknown verb ${JSON.stringify(name)}\n`);
+        diagnose(err, `unknown verb ${JSON.stringify(name)}`);
     }
     err.write(USAGE);
     return EXIT_USAGE;
@@ -196,7 +186,7 @@ function invoke(verb, own, args, streams, openClient) {
             openClient: (config) => {
                 opened = openClient({
                     collectTiming: false,
-                    components: { extensions: config.ts.componentExtensions, host: streams.host },
+                    components: { extensions: config.ts.component_extensions, host: streams.host },
                 });
                 return opened;
             },
@@ -207,29 +197,28 @@ function invoke(verb, own, args, streams, openClient) {
         return refuse(error, streams.err);
     }
 }
-/** Turns one refusal into the exit code the Contract's table gives it. */
+/**
+ * Turns one refusal into the exit code the Contract's table gives it. An error no class names
+ * is a fault of this analyzer, printed with its stack for the maintainers it asks the user to
+ * report it to.
+ */
 function refuse(error, err) {
-    if (error instanceof ConfigError) {
-        err.write(`deadset-ts: ${error.message}\n`);
+    if (error instanceof UsageError) {
+        diagnose(err, error.message);
         err.write(USAGE);
         return EXIT_USAGE;
     }
-    if (error instanceof DiscoveryError) {
-        for (const diagnostic of error.diagnostics) {
-            err.write(`${renderDiagnostic(diagnostic)}\n`);
+    if (!(error instanceof FailureExit)) {
+        if (error instanceof Error && error.stack !== undefined) {
+            err.write(`${error.stack}\n`);
         }
-        err.write(`deadset-ts: ${error.message}\n`);
-        return EXIT_FAILURE;
+        return refuse(productFault(`meets an error none of its classes names: ${message(error)}`), err);
     }
-    if (error instanceof SetupError) {
-        for (const failure of error.failures) {
-            err.write(`${setupLine(failure)}\n`);
-        }
-        return EXIT_FAILURE;
+    for (const diagnostic of error.diagnostics) {
+        err.write(`${renderDiagnostic(diagnostic)}\n`);
     }
-    if (error instanceof ScopeError) {
-        err.write(`deadset-ts: ${error.message}\n`);
-        return EXIT_FAILURE;
+    for (const line of failureLines(error.failures)) {
+        err.write(`${line}\n`);
     }
-    throw error;
+    return EXIT_FAILURE;
 }