@cplieger/deadset-ts 4.0.0 → 5.0.0

package/dist/src/references.js

@@ -1,16 +1,16 @@
-import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExternalModuleReference, isForInStatement, isForOfStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, nodeKey } from "./inventory.js";
 import { relativePath } from "./paths.js";
-import { byPosition, renderPosition } from "./position.js";
+import { byPosition, isComponentFile, renderPosition } from "./position.js";
 import { DEFAULT_BATCH_CAP, UNANSWERED } from "./query.js";
+import { typeQueryAliases } from "./type-query-alias.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
- * among them: it reads its target only to write the result back, so nothing else
- * receives what it read, and a declaration whose every other reference is one of these
- * carries no information out of itself.
+ * among them: where its value is discarded it reads its target only to write the result
+ * back, so nothing else receives what it read.
  */
 const ASSIGNMENTS = new Set([
     SyntaxKind.EqualsToken,
@@ -30,6 +30,36 @@ const ASSIGNMENTS = new Set([
     SyntaxKind.QuestionQuestionEqualsToken,
     SyntaxKind.CaretEqualsToken,
 ]);
+/**
+ * The assignments that read their target to decide whether to store at all, so the read
+ * carries information out whatever becomes of the result.
+ */
+const LOGICAL_ASSIGNMENTS = new Set([
+    SyntaxKind.BarBarEqualsToken,
+    SyntaxKind.AmpersandAmpersandEqualsToken,
+    SyntaxKind.QuestionQuestionEqualsToken,
+]);
+/**
+ * Whether the value of one store expression is discarded: it is a statement of its own, a
+ * clause of a `for` loop, the operand of `void`, or the left operand of a comma.
+ */
+function valueDiscarded(node) {
+    let child = node;
+    let parent = node.parent;
+    while (isParenthesizedExpression(parent)) {
+        child = parent;
+        parent = parent.parent;
+    }
+    if (isExpressionStatement(parent) || isVoidExpression(parent)) {
+        return true;
+    }
+    if (isForStatement(parent)) {
+        return parent.initializer === child || parent.incrementor === child;
+    }
+    return (isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.CommaToken &&
+        parent.left === child);
+}
 /** Whether one node is an identifier or a private name, the two forms a name takes. */
 function isName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
@@ -97,12 +127,18 @@ function markWrite(target, writes) {
  * Records every store one node performs: an assignment, a compound assignment, an
  * increment or a decrement, a `delete`, and an iteration that assigns to a name declared
  * elsewhere. An iteration that declares its own name stores into nothing the inventory
- * holds.
+ * holds. A store that reads its target as well records it in `reads`: a logical
+ * assignment, and a compound assignment, an increment or a decrement whose value is used.
  */
-function markStores(node, writes) {
+function markStores(node, writes, reads) {
     if (isBinaryExpression(node)) {
-        if (ASSIGNMENTS.has(node.operatorToken.kind)) {
+        const operator = node.operatorToken.kind;
+        if (ASSIGNMENTS.has(operator)) {
             markWrite(node.left, writes);
+            if (LOGICAL_ASSIGNMENTS.has(operator) ||
+                (operator !== SyntaxKind.EqualsToken && !valueDiscarded(node))) {
+                markWrite(node.left, reads);
+            }
         }
         return;
     }
@@ -110,6 +146,9 @@ function markStores(node, writes) {
         if (node.operator === SyntaxKind.PlusPlusToken ||
             node.operator === SyntaxKind.MinusMinusToken) {
             markWrite(node.operand, writes);
+            if (!valueDiscarded(node)) {
+                markWrite(node.operand, reads);
+            }
         }
         return;
     }
@@ -198,15 +237,17 @@ function linksOf(file, node, declarations, enclosing) {
  * order, each with its enclosing declaration and its use, and every re-export the file
  * writes. One walk answers all of it, because a second would have to agree with this one
  * about which nodes are names. A declaration's own declared name is left out, which is
- * what makes a declaration referenced only from its own site an unreferenced one.
+ * what makes a declaration referenced only from its own site an unreferenced one, and so
+ * is every node of `unread`, a subtree that is no use.
  */
-function sitesOf(file, declarations, fileId) {
+function sitesOf(file, declarations, fileId, unread) {
     const found = [];
     const reads = [];
     const links = [];
     const evaluations = [];
     const decorated = [];
     const writes = new Set();
+    const alsoRead = new Set();
     const declared = new Set();
     const shorthands = new Map();
     let enclosing = fileId;
@@ -228,19 +269,23 @@ function sitesOf(file, declarations, fileId) {
         }
     };
     const visit = (node) => {
+        if (unread.has(node)) {
+            return;
+        }
         if (isName(node)) {
             if (!declared.has(node.pos)) {
-                found.push({
-                    node,
-                    shorthand: shorthands.get(node.pos),
-                    from: enclosing,
-                    use: writes.has(node.pos) ? "write" : "read",
-                });
+                const site = { node, shorthand: shorthands.get(node.pos), from: enclosing };
+                if (writes.has(node.pos)) {
+                    found.push({ ...site, use: "write" });
+                }
+                if (!writes.has(node.pos) || alsoRead.has(node.pos)) {
+                    found.push({ ...site, use: "read" });
+                }
             }
             return;
         }
         markNames(node);
-        markStores(node, writes);
+        markStores(node, writes, alsoRead);
         for (const read of propertyReadsOf(node)) {
             reads.push({ ...read, from: enclosing });
         }
@@ -265,6 +310,8 @@ function sitesOf(file, declarations, fileId) {
     file.forEachChild(visit);
     return { uses: found, reads, links, evaluations, decorated };
 }
+/** The rule a file the analysis classified as test-support code is counted under. */
+const TEST_SUPPORT_RULE = "test-support";
 /**
  * The name one test-file rule takes. A rule's name is a word list the report's own
  * vocabulary spells, which cannot carry a pattern, so a rule is named by the place of
@@ -277,17 +324,19 @@ function patternRule(index) {
  * The rules over the test files of several projects at once, ordered by rule: a file two
  * projects hold is one file, so each rule counts the distinct paths it matches.
  */
-export function testFileRulesOf(testFiles, paths) {
+export function testFileRulesOf(testFiles, paths, supportFiles = []) {
     const distinct = [...new Set(paths)];
-    return testFiles
-        .map((pattern, index) => {
-        const expression = globExpression(pattern);
-        return {
-            rule: patternRule(index),
-            matched: distinct.filter((path) => expression.test(path)).length,
-        };
-    })
-        .sort((a, b) => compare(a.rule, b.rule));
+    const support = new Set(supportFiles).size;
+    return [
+        ...testFiles.map((pattern, index) => {
+            const expression = globExpression(pattern);
+            return {
+                rule: patternRule(index),
+                matched: distinct.filter((path) => expression.test(path)).length,
+            };
+        }),
+        ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
+    ].sort((a, b) => compare(a.rule, b.rule));
 }
 const importedCache = new WeakMap();
 /**
@@ -332,6 +381,37 @@ function importedNames(file) {
     importedCache.set(file, names);
     return names;
 }
+/**
+ * The name node of every import binding one file's top level declares, and whether it
+ * binds a whole module.
+ */
+function importBindings(file) {
+    const found = [];
+    for (const statement of file.statements) {
+        if (isImportEqualsDeclaration(statement)) {
+            found.push({ node: statement.name, whole: true });
+            continue;
+        }
+        const clause = isImportDeclaration(statement) ? statement.importClause : undefined;
+        if (clause === undefined) {
+            continue;
+        }
+        if (clause.name !== undefined) {
+            found.push({ node: clause.name, whole: false });
+        }
+        const bindings = clause.namedBindings;
+        if (bindings === undefined) {
+            continue;
+        }
+        if (bindings.kind === SyntaxKind.NamespaceImport) {
+            found.push({ node: bindings.name, whole: true });
+        }
+        else {
+            found.push(...bindings.elements.map((element) => ({ node: element.name, whole: false })));
+        }
+    }
+    return found;
+}
 /** Two strings ordered bytewise, which is the order every set of a run is read in. */
 function compare(a, b) {
     if (a === b) {
@@ -376,6 +456,20 @@ export function references(project, held, targetRoot, options) {
             .filter((file) => relativePath(consumer.root, file.fileName) !== undefined &&
             relativePath(targetRoot, file.fileName) === undefined);
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
+    let topLevel;
+    /** The declarations one file's top level holds. */
+    const declaredIn = (fileId) => {
+        if (topLevel === undefined) {
+            const byParent = new Map();
+            for (const symbol of held.symbols) {
+                if (fileIds.has(symbol.parent)) {
+                    byParent.set(symbol.parent, [...(byParent.get(symbol.parent) ?? []), symbol]);
+                }
+            }
+            topLevel = byParent;
+        }
+        return topLevel.get(fileId) ?? [];
+    };
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
     /**
@@ -405,6 +499,45 @@ export function references(project, held, targetRoot, options) {
             ]),
         ];
     };
+    // A type-query alias's own type names its export without using it; a use of the
+    // global is the use, so it names every link of the export's chain as well.
+    const aliases = project.ownSourceFiles().flatMap(typeQueryAliases);
+    const unread = new Set(aliases.map((alias) => alias.type));
+    const aliased = new Map();
+    if (aliases.length > 0) {
+        const exported = project.symbolsAt(aliases.map((alias) => project.handle(alias.exported)));
+        aliases.forEach((alias, index) => {
+            const id = declaredAt(alias.declaration);
+            const symbol = exported[index];
+            if (id === undefined || symbol === undefined) {
+                return;
+            }
+            aliased.set(id, symbol === UNANSWERED
+                ? (declarationsByName(held).get(alias.name) ?? []).map((one) => ({
+                    id: one,
+                    stepped: true,
+                    guessed: true,
+                }))
+                : chains.chainOf(symbol).map((target) => ({ ...target, stepped: true })));
+        });
+    }
+    /** One use's targets, then every link an alias global among them stands for, each once. */
+    const throughAliases = (targets) => {
+        if (aliased.size === 0) {
+            return targets;
+        }
+        const all = [...targets];
+        const seen = new Set(targets.map((target) => target.id));
+        for (const target of targets) {
+            for (const forwarded of aliased.get(target.id) ?? []) {
+                if (!seen.has(forwarded.id)) {
+                    seen.add(forwarded.id);
+                    all.push(forwarded);
+                }
+            }
+        }
+        return all;
+    };
     /** The symbol one site resolves to, asking only the accessor the site's form names. */
     const symbolFor = (site, answered) => {
         if (site.shorthand !== undefined) {
@@ -424,7 +557,11 @@ export function references(project, held, targetRoot, options) {
         if (test) {
             tests.push(path);
         }
-        const { uses, reads, links, evaluations, decorated } = sitesOf(file, declarations, declaredAt(file) ?? "");
+        const fileId = declaredAt(file) ?? "";
+        const { uses, reads, links, evaluations, decorated } = sitesOf(file, declarations, fileId, unread);
+        // A component file's markup may use any binding its blocks declare at the top level.
+        const markup = isComponentFile(file);
+        const bindings = markup ? importBindings(file) : [];
         // A decorator is written inside the declaration it is attached to and receives it,
         // so the declaration is used where the decorator is written, whatever the
         // decorator does with it.
@@ -448,6 +585,7 @@ export function references(project, held, targetRoot, options) {
                 ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
                 ...links.map((link) => link.node),
                 ...evaluations.map((evaluation) => evaluation.node),
+                ...bindings.map((binding) => binding.node),
             ]),
         ];
         const answered = new Map();
@@ -504,6 +642,47 @@ export function references(project, held, targetRoot, options) {
                 }
             }
         }
+        if (markup) {
+            for (const symbol of declaredIn(fileId)) {
+                found.push({
+                    from: fileId,
+                    to: symbol.id,
+                    position: symbol.position,
+                    use: "read",
+                    resolution: "syntax",
+                    test,
+                });
+            }
+            for (const binding of bindings) {
+                const symbol = answered.get(binding.node);
+                if (symbol === undefined) {
+                    continue;
+                }
+                const position = renderPosition(file, root, binding.node.getStart());
+                const chained = symbol === UNANSWERED
+                    ? named(binding.node).map((id) => ({ id, stepped: false, guessed: true }))
+                    : chains.chainOf(symbol);
+                // The markup may name any export of a module a binding holds whole.
+                const targets = binding.whole
+                    ? chained.flatMap((target) => [
+                        target,
+                        ...declaredIn(target.id)
+                            .filter((one) => one.exported)
+                            .map((one) => ({ ...target, id: one.id })),
+                    ])
+                    : chained;
+                for (const target of targets) {
+                    found.push({
+                        from: fileId,
+                        to: target.id,
+                        position,
+                        use: "read",
+                        resolution: target.guessed ? "by-name" : target.stepped ? "alias" : "batch",
+                        test,
+                    });
+                }
+            }
+        }
         // A pattern names a property of the value it destructures, which no name node of
         // the pattern resolves to: a shorthand's name is the local it binds.
         destructured.resolve(reads).forEach((symbol, index) => {
@@ -543,9 +722,9 @@ export function references(project, held, targetRoot, options) {
             const position = renderPosition(file, root, site.node.getStart());
             // A re-export something imports is used and so is the declaration behind it, so
             // the use names every link of the chain its name stands at the head of.
-            const targets = symbol === UNANSWERED
+            const targets = throughAliases(symbol === UNANSWERED
                 ? named(site.node).map((id) => ({ id, stepped: false, guessed: true }))
-                : chains.chainOf(symbol);
+                : chains.chainOf(symbol));
             for (const target of targets) {
                 found.push({
                     from: site.from,

package/dist/src/report.js

@@ -4,12 +4,9 @@
  * renders this document, so no two renderings disagree about which findings exist.
  */
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "6.1.0";
-/**
- * Every report schema version this analyzer reads: the schema versions the Contract it
- * implements admits, each an instance of the one it writes.
- */
-export const SCHEMA_VERSIONS_ACCEPTED = ["6.0.0", SCHEMA_VERSION];
+const SCHEMA_VERSION = "7.0.0";
+/** Every report schema version this analyzer reads: the one the Contract it implements admits. */
+export const SCHEMA_VERSIONS_ACCEPTED = [SCHEMA_VERSION];
 /** The name this analyzer writes every document under and mints every identifier with. */
 export const ANALYZER_NAME = "deadset-ts";
 /** The language this analyzer claims. */
@@ -234,6 +231,29 @@ export function buildReport(input) {
         test_file_rules: [...input.testFileRules]
             .sort((a, b) => compare(a.rule, b.rule) || a.matched - b.matched)
             .map((one) => ({ rule: one.rule, matched: one.matched })),
+        type_error_skips: [
+            ...new Map(input.typeErrorSkips.map((one) => {
+                const skip = { path: one.path, line: one.line, message: one.message };
+                return [JSON.stringify(skip), skip];
+            })),
+        ]
+            .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
+            .map(([, skip]) => skip),
+        notes: [],
+        unanswered_questions: [...input.unanswered]
+            .sort((a, b) => compare(a.configuration, b.configuration) ||
+            compare(JSON.stringify(a), JSON.stringify(b)))
+            .map((one) => ({
+            configuration: one.configuration,
+            questions: one.questions,
+            declarations: one.declarations,
+        })),
+        conventions_applied: input.conventionsApplied.map((one) => ({
+            name: one.name,
+            package: one.package,
+            version: one.version,
+            manifest: one.manifest,
+        })),
         totals: totalsOf(findings, input.result),
     };
 }

package/dist/src/reporters/annotations.js

@@ -22,11 +22,15 @@ function kindName(code) {
 function command(level, at, endLine, title, message) {
     return `::${level} file=${escapeProperty(at.path)},line=${String(at.line)},col=${String(at.column)},endLine=${String(endLine)},title=${escapeProperty(title)}::${escapeData(message)}`;
 }
+/** The title and the message prefix of a type-error skip's annotation. */
+const SKIP_TITLE = "type error skipped";
+const SKIP_MESSAGE = "the analysis did not evaluate the function or statement holding this type error: ";
 /**
  * One workflow annotation per finding, then one per stale suppression, each naming its
- * file, line, column and last line, titled by its code and kind. A finding at or above the
- * failing severity is an error and one below it a warning; a stale suppression is an error,
- * because its kind is fixed on at the failing severity.
+ * file, line, column and last line, titled by its code and kind, then one warning per
+ * type-error skip naming its file and line. A finding at or above the failing severity is
+ * an error and one below it a warning; a stale suppression is an error, because its kind
+ * is fixed on at the failing severity.
  */
 export function annotations(report, options) {
     return coalesced((function* lines() {
@@ -36,5 +40,8 @@ export function annotations(report, options) {
         for (const stale of report.stale_suppressions) {
             yield `${command("error", stale.position, stale.position.line, `${stale.code} ${kindName(stale.code)}`, stale.message)}\n`;
         }
+        for (const skip of report.type_error_skips) {
+            yield `::warning file=${escapeProperty(skip.path)},line=${String(skip.line)},title=${escapeProperty(SKIP_TITLE)}::${escapeData(SKIP_MESSAGE + skip.message)}\n`;
+        }
     })());
 }

package/dist/src/reporters/template.js

@@ -775,7 +775,7 @@ class Execution {
         let held = value;
         for (const name of names) {
             if (!isObject(held)) {
-                throw new RenderError(`can't evaluate field ${name} in a ${kindOf(held)}`);
+                throw new RenderError(`cannot evaluate field ${name} in a ${kindOf(held)}`);
             }
             if (!Object.hasOwn(held, name)) {
                 throw new RenderError(`the document has no member ${JSON.stringify(name)} here`);
@@ -805,9 +805,12 @@ class Execution {
         if (head === undefined) {
             throw new RenderError("empty command");
         }
+        if (head.k === "lit" && head.value === null) {
+            throw new RenderError("nil is not a command");
+        }
         if (head.k !== "func") {
             if (rest.length > 0 || piped !== undefined) {
-                throw new RenderError("can't give an argument to a non-function");
+                throw new RenderError("cannot give an argument to a non-function");
             }
             return this.arg(head, dot);
         }
@@ -903,7 +906,7 @@ class Execution {
                     .map((key) => [key, value[key] ?? null]);
             }
             else {
-                throw new RenderError(`range can't iterate over a ${kindOf(value)}`);
+                throw new RenderError(`range cannot iterate over a ${kindOf(value)}`);
             }
             if (entries.length === 0) {
                 this.run(node.otherwise, dot);

package/dist/src/resolve.js

@@ -1,4 +1,5 @@
 import { ConfigError, defaultConfig, } from "./config.js";
+import { CONVENTION_ROWS } from "./convention-rows.js";
 import { FIXED_SEVERITY_CODES, LIVE_CODES } from "./kinds.js";
 import { checkDocument, malformed, nestFlags, SCHEMA_ROOT, SEVERITY_SECTION, } from "./schema.js";
 /** Names the command-line flags in a refusal, where a document is named by its path. */
@@ -149,6 +150,26 @@ function readStrings(parent, name, path, label, minItems, allowed) {
     }
     return value;
 }
+/** A component file's extension: a full stop followed by letters and digits. */
+const COMPONENT_EXTENSION = /^\.[A-Za-z0-9]+$/u;
+function readComponentExtensions(ts, label) {
+    const extensions = readStrings(ts, "component_extensions", "ts.component_extensions", label, 0);
+    const wrong = extensions?.find((one) => !COMPONENT_EXTENSION.test(one));
+    if (wrong !== undefined) {
+        throw malformed(label, "ts.component_extensions", `${JSON.stringify(wrong)} is not a full stop followed by letters and digits`);
+    }
+    return extensions;
+}
+/** The names of the convention rows this analyzer's table carries. */
+const CONVENTION_NAMES = new Set(CONVENTION_ROWS.map((row) => row.name));
+function readDisabledConventions(ts, label) {
+    const names = readStrings(ts, "disabled_conventions", "ts.disabled_conventions", label, 0);
+    const unknown = names?.find((one) => !CONVENTION_NAMES.has(one));
+    if (unknown !== undefined) {
+        throw malformed(label, "ts.disabled_conventions", `${JSON.stringify(unknown)} names no convention row this analyzer carries`);
+    }
+    return names;
+}
 function requireMember(value, path, label) {
     if (value === undefined || value === "") {
         throw malformed(label, path, "is required and names nothing");
@@ -507,6 +528,8 @@ function readDoc(value, label) {
         providers: readProviders(providers, label),
         testFiles: readStrings(ts, "test_files", "ts.test_files", label, 1),
         entryFiles: readStrings(ts, "entry_files", "ts.entry_files", label, 0),
+        componentExtensions: readComponentExtensions(ts, label),
+        disabledConventions: readDisabledConventions(ts, label),
         injectionRegistrations: readDeclarations(ts, "injection_registrations", "ts.injection_registrations", label),
         lifecycleContracts: readLifecycleContracts(ts, label),
         serializers: readDeclarations(ts, "serializers", "ts.serializers", label),
@@ -667,13 +690,13 @@ export function resolve(inputs) {
     return { config, provenance };
 }
 /**
- * The build matrix the configuration documents resolve to, every document read and
- * refused as {@link resolve} refuses it, and nothing else required of them: which
- * projects a run analyzes depends on the matrix alone, so a question about the
- * projects asks no target kind.
+ * The configuration the documents resolve to, every document read and refused as
+ * {@link resolve} refuses it, with no target kind required of them: which projects a
+ * run analyzes does not depend on the kind, so a question about the projects asks
+ * none. The kind is empty where no document names one.
  */
-export function resolveMatrix(inputs) {
-    return settleAll(inputs).config.analysis.configurations;
+export function resolveUnkinded(inputs) {
+    return settleAll(inputs).config;
 }
 /**
  * Every setting the documents supply, each from the highest-ranked source carrying
@@ -714,6 +737,8 @@ function settleAll(inputs) {
         ts: {
             testFiles: at("ts.test_files", defaults.ts.testFiles, (doc) => doc.testFiles),
             entryFiles: at("ts.entry_files", defaults.ts.entryFiles, (doc) => doc.entryFiles),
+            componentExtensions: at("ts.component_extensions", defaults.ts.componentExtensions, (doc) => doc.componentExtensions),
+            disabledConventions: at("ts.disabled_conventions", defaults.ts.disabledConventions, (doc) => doc.disabledConventions),
             injectionRegistrations: at("ts.injection_registrations", defaults.ts.injectionRegistrations, (doc) => doc.injectionRegistrations),
             lifecycleContracts: at("ts.lifecycle_contracts", defaults.ts.lifecycleContracts, (doc) => doc.lifecycleContracts),
             serializers: at("ts.serializers", defaults.ts.serializers, (doc) => doc.serializers),

package/dist/src/roots.js

@@ -8,12 +8,20 @@
  * under reachability and still a candidate under reference counting.
  */
 import { aliasChains } from "./alias-chain.js";
+import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
+import { typeQueryAliases } from "./type-query-alias.js";
+/** The kind of root each role of a manifest entry makes. */
+const ENTRY_KINDS = {
+    import: "manifest-entry",
+    run: "manifest-binary",
+    script: "script",
+};
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
     return text.includes("*") || text.includes("?");
@@ -117,18 +125,23 @@ export function roots(project, held, targetRoot, options) {
         entered.push({ file, kind, source, exports });
     };
     const published = [];
-    const publishes = (entry) => options.publishedAPI &&
-        entry.published &&
-        (options.manifest.declaresExports ? entry.member.startsWith("exports") : true);
-    for (const entry of options.manifest.entries) {
-        if (publishes(entry)) {
+    const entries = [
+        ...options.manifest.entries.map((entry) => ({
+            entry,
+            publishes: entry.published &&
+                (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
+        })),
+        ...(options.workspaceEntries ?? []).map((entry) => ({ entry, publishes: entry.published })),
+    ];
+    for (const { entry, publishes } of entries) {
+        if (options.publishedAPI && publishes) {
             published.push(...files.named(entry.path));
         }
     }
     const publishedNames = new Set(published.map((file) => file.fileName));
-    for (const entry of options.manifest.entries) {
+    for (const { entry } of entries) {
         for (const file of files.named(entry.path)) {
-            const kind = entry.role === "run" ? "manifest-binary" : "manifest-entry";
+            const kind = ENTRY_KINDS[entry.role];
             enter(file, kind, entry.member, !publishedNames.has(file.fileName));
         }
     }
@@ -140,9 +153,25 @@ export function roots(project, held, targetRoot, options) {
             }
         }
     }
-    for (const point of entryPoints(project, files, options.testFiles)) {
+    for (const { file, row } of options.conventions === undefined
+        ? []
+        : conventionEntries(options.conventions, files)) {
+        enter(file, "convention", row, true);
+    }
+    for (const point of entryPoints(project, files, options.testFiles, options.host, targetRoot)) {
         enter(point.file, point.rule, point.source, point.exports);
     }
+    for (const file of files.byPath.values()) {
+        for (const alias of typeQueryAliases(file)) {
+            const source = alias.type.getText().replace(/\s+/gu, " ");
+            for (const node of [alias.declaration, ...alias.containers]) {
+                const id = declared.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    add(id, "type-query-alias", source);
+                }
+            }
+        }
+    }
     const { tables: exportsOf, answered } = exportTables(project, held, [
         ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
         ...published,

package/dist/src/run.js

@@ -3,6 +3,7 @@ import { DiscoveryError, renderDiagnostic } from "./discover.js";
 import { EMITTERS } from "./findings/emitters.js";
 import { joinPath, resolvePath } from "./paths.js";
 import { readScope, ScopeError, scopeForDir } from "./scope.js";
+import { SetupError, setupLine } from "./setup-failure.js";
 import { openEngine } from "./session.js";
 import { printConfigVerb } from "./verbs/print-config.js";
 import { printProjectsVerb } from "./verbs/print-projects.js";
@@ -158,7 +159,7 @@ function scopeOf(host, options) {
  * `openClient` opens the compiler client; a caller that watches what a run reads
  * supplies its own of either.
  */
-export function run(args, out, err, host, openClient = (collectTiming) => openEngine({ collectTiming })) {
+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`);
@@ -193,8 +194,11 @@ function invoke(verb, own, args, streams, openClient) {
             scope: () => scopeOf(streams.host, read()),
             option: (name) => read().named.get(name),
             repeated: (name) => read().repeated.get(name) ?? [],
-            openClient: (collectTiming) => {
-                opened = openClient(collectTiming);
+            openClient: (config) => {
+                opened = openClient({
+                    collectTiming: false,
+                    components: { extensions: config.ts.componentExtensions, host: streams.host },
+                });
                 return opened;
             },
             emitters: EMITTERS,
@@ -219,6 +223,12 @@ function refuse(error, err) {
         err.write(`deadset-ts: ${error.message}\n`);
         return EXIT_FAILURE;
     }
+    if (error instanceof SetupError) {
+        for (const failure of error.failures) {
+            err.write(`${setupLine(failure)}\n`);
+        }
+        return EXIT_FAILURE;
+    }
     if (error instanceof ScopeError) {
         err.write(`deadset-ts: ${error.message}\n`);
         return EXIT_FAILURE;