@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/conventions.js

@@ -0,0 +1,565 @@
+/**
+ * The convention rows a run applies, and the files they root. A row applies to a
+ * manifest that declares its enabling package when the installed package's version is
+ * in the row's range; its globs are read against that manifest's directory, with every
+ * directory a configuration property moves read from the property's literal value.
+ * No configuration file is run.
+ */
+import { isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { lineOf } from "./component-files.js";
+import { CONVENTION_ROWS, } from "./convention-rows.js";
+import { globExpression } from "./glob.js";
+import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
+import { satisfies } from "./version-range.js";
+/** The sections an installed package is required by, so its absence fails the run. */
+const REQUIRED_SECTIONS = ["dependencies", "devDependencies"];
+const DEPENDENCY_SECTIONS = [
+    ...REQUIRED_SECTIONS,
+    "peerDependencies",
+    "optionalDependencies",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJSON(host, path) {
+    try {
+        return JSON.parse(host.readFile(path));
+    }
+    catch {
+        return undefined;
+    }
+}
+function declares(manifest, name, sections = DEPENDENCY_SECTIONS) {
+    if (!isRecord(manifest)) {
+        return false;
+    }
+    return sections.some((section) => {
+        const held = manifest[section];
+        return isRecord(held) && Object.hasOwn(held, name);
+    });
+}
+/**
+ * The version the installed package's manifest names, read from the nearest
+ * `node_modules` at or above `dir` that holds it, `""` where that manifest names
+ * none, or `undefined` where no `node_modules` holds it.
+ */
+function installedVersion(host, dir, name) {
+    for (let at = normalizePath(dir);; at = dirnamePath(at)) {
+        const path = joinPath(at, "node_modules", name, "package.json");
+        if (host.kindOf(path) === "file") {
+            const manifest = readJSON(host, path);
+            const version = isRecord(manifest) ? manifest["version"] : undefined;
+            return typeof version === "string" ? version : "";
+        }
+        if (dirnamePath(at) === at) {
+            return undefined;
+        }
+    }
+}
+/** Whether one node wraps an expression without changing its value. */
+function isWrapper(node) {
+    return (isParenthesizedExpression(node) ||
+        isAsExpression(node) ||
+        isSatisfiesExpression(node) ||
+        isNonNullExpression(node));
+}
+/** The expression a wrapper that changes no value holds. */
+function unwrapped(node) {
+    let at = node;
+    while (isWrapper(at)) {
+        at = at.expression;
+    }
+    return at;
+}
+/** The key one property is written with, where it is written as a name or as literal text. */
+function keyOf(property) {
+    if (!isPropertyAssignment(property) && !isShorthandPropertyAssignment(property)) {
+        return undefined;
+    }
+    const { name } = property;
+    const key = isComputedPropertyName(name) ? name.expression : name;
+    if ((isIdentifier(key) && key === name) ||
+        isStringLiteral(key) ||
+        isNoSubstitutionTemplateLiteral(key)) {
+        return key.text;
+    }
+    return undefined;
+}
+/** Whether one member's computed name is no literal, so it may set any key. */
+function computesKey(member) {
+    const name = member.name;
+    if (name === undefined || !isComputedPropertyName(name)) {
+        return false;
+    }
+    const key = name.expression;
+    return !(isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key));
+}
+/** The values one file's top-level variable declarations bind, by name. */
+function declaredValues(file) {
+    const values = new Map();
+    for (const statement of file.statements) {
+        if (isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (isIdentifier(declaration.name) && declaration.initializer !== undefined) {
+                    values.set(declaration.name.text, declaration.initializer);
+                }
+            }
+        }
+    }
+    return values;
+}
+function isModuleExports(node) {
+    return (isPropertyAccessExpression(node) &&
+        isIdentifier(node.expression) &&
+        node.expression.text === "module" &&
+        node.name.text === "exports");
+}
+/** Every expression or declaration one file exports as its default, in any module syntax. */
+function defaultExports(file) {
+    const found = [];
+    for (const statement of file.statements) {
+        if (isExportAssignment(statement)) {
+            found.push(statement.expression);
+        }
+        else if ((isFunctionDeclaration(statement) || isClassDeclaration(statement)) &&
+            statement.modifiers?.some((one) => one.kind === SyntaxKind.DefaultKeyword) === true) {
+            found.push(statement);
+        }
+        else if (isExportDeclaration(statement) &&
+            statement.moduleSpecifier === undefined &&
+            statement.exportClause !== undefined &&
+            isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements) {
+                if (element.name.text === "default") {
+                    found.push(element.propertyName ?? element.name);
+                }
+            }
+        }
+        else if (isExpressionStatement(statement) &&
+            isBinaryExpression(statement.expression) &&
+            statement.expression.operatorToken.kind === SyntaxKind.EqualsToken &&
+            isModuleExports(statement.expression.left)) {
+            found.push(statement.expression.right);
+        }
+    }
+    return found;
+}
+/** The declarations whose name is a binding of the scope they are written in. */
+const BINDING_KINDS = new Set([
+    SyntaxKind.VariableDeclaration,
+    SyntaxKind.Parameter,
+    SyntaxKind.BindingElement,
+    SyntaxKind.FunctionDeclaration,
+    SyntaxKind.ClassDeclaration,
+    SyntaxKind.ImportClause,
+    SyntaxKind.ImportSpecifier,
+    SyntaxKind.NamespaceImport,
+    SyntaxKind.ImportEqualsDeclaration,
+]);
+/** Whether one file declares a binding named `require` at any depth, which shadows the global. */
+function declaresRequire(file) {
+    let found = false;
+    const visit = (node) => {
+        const name = node.name;
+        if (name !== undefined &&
+            isIdentifier(name) &&
+            name.text === "require" &&
+            BINDING_KINDS.has(node.kind)) {
+            found = true;
+        }
+        if (!found) {
+            node.forEachChild(visit);
+        }
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * The top-level `const`, `let` and `var` declarations that bind a `require` of one module,
+ * written with the module's name as its one string-literal argument, in a file that
+ * declares no binding named `require`: each binds as an import of the module does.
+ */
+function requireBindings(file, module) {
+    const found = [];
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const value = declaration.initializer === undefined ? undefined : unwrapped(declaration.initializer);
+            const [argument, ...rest] = value !== undefined && isCallExpression(value) ? value.arguments : [];
+            if (value === undefined ||
+                !isCallExpression(value) ||
+                !isIdentifier(value.expression) ||
+                value.expression.text !== "require" ||
+                argument === undefined ||
+                rest.length > 0 ||
+                !isStringLiteral(argument) ||
+                argument.text !== module) {
+                continue;
+            }
+            if (isIdentifier(declaration.name) || isObjectBindingPattern(declaration.name)) {
+                found.push(declaration.name);
+            }
+        }
+    }
+    return found.length > 0 && declaresRequire(file) ? [] : found;
+}
+/**
+ * The first argument of every call one file makes to one module's export, through a
+ * named or a namespace import; `undefined` for a call with no argument.
+ */
+function optionsArguments(file, call) {
+    const names = new Set();
+    const namespaces = new Set();
+    for (const name of requireBindings(file, call.module)) {
+        if (isIdentifier(name)) {
+            namespaces.add(name.text);
+            continue;
+        }
+        for (const element of name.elements) {
+            const local = element.name;
+            const exported = element.propertyName ?? local;
+            if (element.dotDotDotToken === undefined &&
+                local !== undefined &&
+                isIdentifier(local) &&
+                exported !== undefined &&
+                (isIdentifier(exported) || isStringLiteral(exported)) &&
+                exported.text === call.export) {
+                names.add(local.text);
+            }
+        }
+    }
+    for (const statement of file.statements) {
+        const bindings = isImportDeclaration(statement)
+            ? statement.importClause?.namedBindings
+            : undefined;
+        if (bindings === undefined ||
+            !isImportDeclaration(statement) ||
+            !isStringLiteral(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== call.module) {
+            continue;
+        }
+        if (isNamespaceImport(bindings)) {
+            namespaces.add(bindings.name.text);
+            continue;
+        }
+        for (const element of bindings.elements) {
+            if ((element.propertyName ?? element.name).text === call.export) {
+                names.add(element.name.text);
+            }
+        }
+    }
+    const found = [];
+    const visit = (node) => {
+        if (isCallExpression(node)) {
+            const callee = unwrapped(node.expression);
+            const named = isIdentifier(callee) && names.has(callee.text);
+            const throughNamespace = isPropertyAccessExpression(callee) &&
+                isIdentifier(callee.expression) &&
+                namespaces.has(callee.expression.text) &&
+                callee.name.text === call.export;
+            if (named || throughNamespace) {
+                found.push(node.arguments[0]);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * The object literal one expression stands for, read through the file's top-level
+ * declarations and, where `throughCalls`, through a call's first argument: `undefined`
+ * for a call with no argument, and any other node where the expression is not written
+ * out as an object literal.
+ */
+function objectOf(node, declared, throughCalls, seen = new Set()) {
+    const at = unwrapped(node);
+    if (isIdentifier(at)) {
+        const value = declared.get(at.text);
+        if (value !== undefined && !seen.has(at.text)) {
+            return objectOf(value, declared, throughCalls, new Set([...seen, at.text]));
+        }
+    }
+    else if (throughCalls && isCallExpression(at)) {
+        const [first] = at.arguments;
+        return first === undefined ? undefined : objectOf(first, declared, throughCalls, seen);
+    }
+    return at;
+}
+/**
+ * Reads the values at one path of keys below one object literal into `values`, and
+ * answers the first member that does not write its value out: a spread, a value that is
+ * not a literal at the path's end, or one that is not an object literal before it.
+ */
+function readPath(object, keys, values) {
+    const [key, ...rest] = keys;
+    for (const member of object.properties) {
+        if (isSpreadAssignment(member) || computesKey(member)) {
+            return member;
+        }
+        if (keyOf(member) !== key) {
+            continue;
+        }
+        const held = isPropertyAssignment(member) ? unwrapped(member.initializer) : undefined;
+        if (rest.length === 0) {
+            if (held === undefined || !(isStringLiteral(held) || isNoSubstitutionTemplateLiteral(held))) {
+                return member;
+            }
+            values.push(held.text);
+        }
+        else {
+            if (held === undefined || !isObjectLiteralExpression(held)) {
+                return member;
+            }
+            const failed = readPath(held, rest, values);
+            if (failed !== undefined) {
+                return failed;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Every value one file writes at one property's path inside the object it is read from:
+ * the options argument of every call `call` names, or the file's default export. A string
+ * literal or a template literal with no substitution is the value. A read object, or an
+ * object along the path, that is not written out as an object literal, or that spreads
+ * another object into itself, is not a literal, and neither is any other value at the path.
+ */
+export function readProperty(file, property, call) {
+    const declared = declaredValues(file);
+    const objects = call === undefined
+        ? defaultExports(file).map((one) => objectOf(one, declared, true))
+        : optionsArguments(file, call).map((one) => one === undefined ? undefined : objectOf(one, declared, false));
+    const values = [];
+    for (const object of objects) {
+        if (object === undefined) {
+            continue;
+        }
+        const notLiteral = isObjectLiteralExpression(object)
+            ? readPath(object, property.split("."), values)
+            : object;
+        if (notLiteral !== undefined) {
+            return { values, notLiteral };
+        }
+    }
+    return { values };
+}
+/** A directory below a manifest's, `.` for the directory itself, `undefined` outside it. */
+function below(dir, path) {
+    return normalizePath(path) === normalizePath(dir) ? "." : relativePath(dir, path);
+}
+/**
+ * Every text a template stands for, each placeholder replaced by every directory its move
+ * resolved to. A placeholder whose move resolved outside the manifest's directory leaves
+ * the text standing for nothing.
+ */
+function expand(template, resolved) {
+    const match = /<([A-Za-z]+)>/u.exec(template);
+    if (match === null) {
+        return [template];
+    }
+    const [placeholder, id = ""] = match;
+    const out = [];
+    for (const value of resolved.get(id) ?? []) {
+        if (value === undefined) {
+            continue;
+        }
+        const replaced = value === "." && template.startsWith(`${placeholder}/`, match.index)
+            ? template.replace(`${placeholder}/`, "")
+            : template.replace(placeholder, value);
+        out.push(...expand(replaced, resolved));
+    }
+    return out;
+}
+/** The configuration files in one directory that one glob names, by name. */
+function configurationFiles(host, dir, glob) {
+    const expression = globExpression(glob);
+    let entries;
+    try {
+        entries = host.readDirectory(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => !entry.directory && expression.test(entry.name))
+        .map((entry) => entry.name)
+        .sort();
+}
+function resolveMove(host, parse, dir, row, move, resolved) {
+    const set = [];
+    for (const reading of move.readings) {
+        for (const glob of reading.files) {
+            for (const name of configurationFiles(host, dir, glob)) {
+                const path = joinPath(dir, name);
+                let text;
+                try {
+                    text = host.readFile(path);
+                }
+                catch {
+                    continue;
+                }
+                const file = parse(path, text);
+                const read = readProperty(file, reading.property, reading.call);
+                if (read.notLiteral !== undefined) {
+                    const line = lineOf(text, read.notLiteral.getStart());
+                    return {
+                        failure: `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
+                            `the convention row ${row.name} reads, to a value that is not a string literal: ` +
+                            `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
+                            `files in ts.entry_files`,
+                    };
+                }
+                set.push(...read.values);
+            }
+        }
+    }
+    const dirs = [];
+    for (const base of expand(move.base ?? ".", resolved)) {
+        const against = joinPath(dir, base);
+        const texts = set.length > 0 ? set : move.defaults.flatMap((one) => expand(one, resolved));
+        for (const text of texts) {
+            dirs.push(below(dir, resolvePath(against, text)));
+        }
+    }
+    return { dirs: [...new Set(dirs)] };
+}
+/** Two strings ordered bytewise. */
+function compare(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    return a < b ? -1 : 1;
+}
+/**
+ * What the rows decide over the manifests the analysis reads. A row `disabled` names
+ * is skipped before anything is read for it.
+ */
+export function readConventions(host, parse, manifests, disabled, rows = CONVENTION_ROWS) {
+    const applied = [];
+    const globs = [];
+    const generated = [];
+    const failures = [];
+    for (const manifest of manifests) {
+        const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
+        const versions = new Map();
+        const missing = new Set();
+        for (const row of rows) {
+            if (disabled.includes(row.name) || !declares(declared, row.package)) {
+                continue;
+            }
+            if (!versions.has(row.package)) {
+                versions.set(row.package, installedVersion(host, manifest.dir, row.package));
+            }
+            const version = versions.get(row.package);
+            if (version === undefined) {
+                if (missing.has(row.package) || !declares(declared, row.package, REQUIRED_SECTIONS)) {
+                    continue;
+                }
+                missing.add(row.package);
+                failures.push({
+                    dir: manifest.dir,
+                    failure: {
+                        setupClass: "missing-module",
+                        detail: `${manifest.path} declares ${row.package}, which no node_modules at or ` +
+                            `above its directory holds: run the package manager's install`,
+                    },
+                });
+                continue;
+            }
+            if (!satisfies(version, row.range)) {
+                continue;
+            }
+            const resolved = new Map();
+            let failed;
+            for (const move of row.moves) {
+                const result = resolveMove(host, parse, manifest.dir, row, move, resolved);
+                if ("failure" in result) {
+                    failed = result.failure;
+                    break;
+                }
+                resolved.set(move.id, result.dirs);
+            }
+            if (failed !== undefined) {
+                const where = dirnamePath(manifest.path);
+                failures.push({
+                    dir: manifest.dir,
+                    failure: {
+                        setupClass: "convention-not-literal",
+                        detail: where === "." ? failed : `${where}/${failed}`,
+                    },
+                });
+                continue;
+            }
+            applied.push({
+                name: row.name,
+                package: row.package,
+                version,
+                manifest: manifest.path,
+            });
+            const excludes = [
+                ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
+            ].map(globExpression);
+            for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
+                generated.push({ dir: manifest.dir, row: row.name, below });
+            }
+            for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
+                globs.push({
+                    dir: manifest.dir,
+                    row: row.name,
+                    expression: globExpression(glob),
+                    excludes,
+                });
+            }
+        }
+    }
+    const unique = [...new Map(applied.map((one) => [JSON.stringify(one), one])).values()];
+    unique.sort((a, b) => compare(a.name, b.name) ||
+        compare(a.manifest, b.manifest) ||
+        compare(JSON.stringify(a), JSON.stringify(b)));
+    return { applied: unique, globs, generated, failures };
+}
+/**
+ * Every own file of one project below a directory an applied row names as generated, by
+ * its path below the target root, with the name of the first such row.
+ */
+export function generatedFiles(conventions, files) {
+    const found = new Map();
+    for (const { dir, row, below } of conventions.generated) {
+        const root = joinPath(dir, below);
+        for (const [path, file] of files.byPath) {
+            if (!found.has(path) && relativePath(root, file.fileName) !== undefined) {
+                found.set(path, row);
+            }
+        }
+    }
+    return found;
+}
+/** Every own file of one project an applied row's globs match, once per row. */
+export function conventionEntries(conventions, files) {
+    const found = new Map();
+    for (const glob of conventions.globs) {
+        for (const file of files.byName.values()) {
+            const path = relativePath(glob.dir, file.fileName);
+            if (path !== undefined &&
+                glob.expression.test(path) &&
+                !glob.excludes.some((one) => one.test(path))) {
+                found.set(`${file.fileName}\u0000${glob.row}`, { file, row: glob.row });
+            }
+        }
+    }
+    return [...found.values()];
+}
+/**
+ * The failures the rows met that hold for one configuration: those of a manifest whose
+ * directory holds the configuration file or one of the files the project owns.
+ */
+export function conventionFailuresFor(conventions, configFile, ownFiles) {
+    return conventions.failures
+        .filter(({ dir }) => below(dir, dirnamePath(configFile)) !== undefined ||
+        ownFiles.some((file) => relativePath(dir, file) !== undefined))
+        .map(({ failure }) => failure);
+}

package/dist/src/dependencies.js

@@ -2,13 +2,16 @@
  * The dependencies the target's manifest declares, and what the projects' own files
  * need from outside the target. A file needs a package it imports, re-exports from,
  * augments or references the types of, by name or through the file the specifier
- * resolves to; a configuration needs one it names. A package one dependency pulls in
+ * resolves to; a compiler configuration needs one it names, and a configuration file a
+ * tool loads needs each dependency its strings spell. A package one dependency pulls in
  * for itself is that dependency's need, not the target's.
  */
 import { isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, } from "./configuration-files.js";
 import { nodeKey, packageScope } from "./inventory.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
+import { sourceFilesOf } from "./source-files.js";
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
@@ -181,9 +184,10 @@ function bindingsOf(node) {
  * Every package one project needs, and which declaration each use is written in.
  * One local walk and one batched resolution per file: a use of an import binding is
  * an identifier resolving to the binding's own symbol, so a local declaration that
- * shadows the name is not one.
+ * shadows the name is not one. A string of a configuration file uses each dependency
+ * the manifest beside the file declares that it spells.
  */
-export function projectNeeds(project, held, host) {
+export function projectNeeds(project, held, host, targetRoot, parse) {
     const programPackages = new Set();
     for (const name of project.program.getSourceFileNames()) {
         const named = packageOfPath(name);
@@ -211,6 +215,35 @@ export function projectNeeds(project, held, host) {
     for (const file of project.ownSourceFiles()) {
         unanswered = fileNeeds(project, held, file, programPackages, use) || unanswered;
     }
+    const beside = new Map();
+    const declaredAt = (path) => {
+        const dir = dirnamePath(path);
+        let names = beside.get(dir);
+        if (names === undefined) {
+            names = declaredBeside(host, dir);
+            beside.set(dir, names);
+        }
+        return names;
+    };
+    const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot), parse);
+    for (const { file } of configuration.modules) {
+        const names = declaredAt(file.fileName);
+        for (const { node, text } of moduleStrings(file)) {
+            use(ownersOf(file, held, node), dependenciesNamed(text, names));
+        }
+    }
+    for (const document of configuration.documents) {
+        const names = declaredAt(document.path);
+        for (const text of document.strings) {
+            use([PROJECT_OWNER], dependenciesNamed(text, names));
+        }
+    }
+    for (const { file, manifestDir } of configuration.outside) {
+        const names = declaredAt(joinPath(manifestDir, "package.json"));
+        for (const { text } of moduleStrings(file)) {
+            use([PROJECT_OWNER], dependenciesNamed(text, names));
+        }
+    }
     return { packages, uses, unanswered };
 }
 /** The declarations of the inventory a use written at one node belongs to. */

package/dist/src/destructuring.js

@@ -7,7 +7,7 @@
  */
 import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { TypeFlags } from "@typescript/native/unstable/sync";
-import { isAnswered, UNANSWERED } from "./query.js";
+import { isAnswered, propertyTables, UNANSWERED, } from "./query.js";
 /** The text a property name spells, or `undefined` for a computed name. */
 function nameText(node) {
     if (node === undefined) {
@@ -151,7 +151,7 @@ function sourceOf(target) {
  * read once per type for the whole project, since one type is destructured in many
  * places and a table answers every name of it.
  */
-export function destructuring(project, cap) {
+export function destructuring(project, cap, properties = propertyTables(project.queries)) {
     const queries = project.queries;
     const tables = new Map();
     let patternBatches = 0;
@@ -163,10 +163,10 @@ export function destructuring(project, cap) {
         }
         let table = new Map();
         if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
-            patternLookups += 1;
-            const properties = queries.propertiesOf(type);
-            table = isAnswered(properties)
-                ? new Map(properties.map((property) => [property.name, property]))
+            const read = properties.of(type);
+            patternLookups += read.asked ? 1 : 0;
+            table = isAnswered(read.properties)
+                ? new Map(read.properties.map((property) => [property.name, property]))
                 : UNANSWERED;
         }
         tables.set(type.id, table);

package/dist/src/discover.js

@@ -1,5 +1,6 @@
 import { DiagnosticCategory } from "@typescript/native/unstable/sync";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { SetupError } from "./setup-failure.js";
 /** Directory names discovery does not descend into. */
 export const IGNORED_DIRECTORIES = new Set(["node_modules", ".git"]);
 /** A compiler configuration file discovery recognises under a root. */
@@ -217,10 +218,16 @@ function derivedFrom(engine, host, pending, unreadable) {
  */
 export function consumerProjects(engine, host, root) {
     const kind = host.kindOf(root);
+    if (kind === "absent") {
+        throw new SetupError([
+            {
+                setupClass: "missing-consumer",
+                detail: `the scope declares the consumer ${root}, and nothing is at that path: check the consumer out at ${root} and install its dependencies`,
+            },
+        ]);
+    }
     if (kind !== "directory") {
-        throw new DiscoveryError(kind === "absent"
-            ? `the consumer ${root} does not exist`
-            : `the consumer ${root} is not a directory`, []);
+        throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
     }
     const found = derivedFrom(engine, host, configFilesUnder(host, root));
     if (found.length === 0) {