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

package/dist/src/augmentations.js

@@ -6,9 +6,11 @@
  * name, which the language or a library types values by where the target never names it,
  * as `import.meta` or `process.env`, so a use of its member is a use of it.
  */
-import { referenceKey } from "./matrix.js";
+import { isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, } from "@typescript/native/ast";
+import { nodeKey } from "./inventory.js";
+import { referenceKey } from "./liveness/matrix.js";
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
-function isGlobalBlock(symbol, held, files) {
+export function isGlobalBlock(symbol, held, files) {
     return (symbol.kind === "namespace" &&
         files.has(symbol.parent) &&
         symbol.ref.endsWith("#global") &&
@@ -48,12 +50,71 @@ function holdersOf(held, scripts) {
  * file or a `declare` holds that a `declare global` block, or the top level of a file in
  * `scripts`, declares, directly or inside a namespace there.
  */
-export function ambientGlobalInterfaces(held, interfaces, scripts) {
+function ambientGlobalInterfaces(held, interfaces, scripts) {
     const holders = holdersOf(held, scripts);
     return holders === undefined
         ? []
         : interfaces.filter((id) => held.ambient.has(id) && holders(id).global);
 }
+/**
+ * Which ambient global interfaces of the project's own files, `files`, merge into an interface
+ * declared outside them, and what each merge keeps.
+ */
+export function mergedGlobalInterfaces(project, held, files) {
+    const scripts = new Set();
+    const names = new Map();
+    for (const file of files.byName.values()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId !== undefined && file.externalModuleIndicator === undefined) {
+            scripts.add(fileId);
+        }
+        const visit = (node) => {
+            if (isInterfaceDeclaration(node)) {
+                const id = held.declarations.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    names.set(id, node.name);
+                }
+            }
+            else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+                node.forEachChild(visit);
+            }
+        };
+        file.forEachChild(visit);
+    }
+    const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+    const asked = [...names].filter(([id]) => global.has(id));
+    if (asked.length === 0) {
+        return { scripts, interfaces: new Set(), kept: [] };
+    }
+    const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+    const holders = holdersOf(held, scripts);
+    const empty = (handle) => {
+        if (project.program.getSourceFileMetadata(handle.path)?.isDefaultLibrary === true) {
+            return false;
+        }
+        const node = project.declarationAt(handle)?.node;
+        return node !== undefined && isInterfaceDeclaration(node) && node.members.length === 0;
+    };
+    const interfaces = new Set();
+    const kept = new Set();
+    asked.forEach(([id], at) => {
+        const symbol = answers[at];
+        const outside = typeof symbol === "object"
+            ? symbol.declarations.filter((handle) => !files.byName.has(handle.path))
+            : [];
+        if (outside.length === 0) {
+            return;
+        }
+        interfaces.add(id);
+        const members = outside.every(empty)
+            ? held.symbols.filter((one) => one.parent === id).map((one) => one.id)
+            : [];
+        for (const one of [id, ...(holders?.(id).ids ?? []), ...members]) {
+            kept.add(one);
+        }
+    });
+    return { scripts, interfaces, kept: [...kept] };
+}
 /**
  * For each reference to a declaration an augmentation block, or the global scope of a
  * file in `scripts` (the files that are no module), holds, a read at the same place of

package/dist/src/automatic-types.js

@@ -5,7 +5,9 @@
  * declarations, and a use of one resolves to nothing; each such use is a use of the package.
  */
 import { isClassDeclaration, isEnumDeclaration, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, isStringLiteral, isTypeAliasDeclaration, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
-import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { entriesOf } from "./fs/tree.js";
+import { manifestAt } from "./fs/manifest.js";
 const TYPE_ROOT = "node_modules/@types";
 const NONE = { globals: new Map(), modules: new Map() };
 /**
@@ -73,19 +75,11 @@ function fileDeclarations(file, globals, modules) {
 }
 /** The entry declaration file of one installed type package's directory. */
 function entryOf(host, dir) {
-    try {
-        const manifest = JSON.parse(host.readFile(joinPath(dir, "package.json")));
-        const named = typeof manifest === "object" && manifest !== null
-            ? (manifest["types"] ??
-                manifest["typings"])
-            : undefined;
-        if (typeof named === "string" && named !== "") {
-            const path = resolvePath(dir, named);
-            return path.endsWith(".ts") ? path : `${path}.d.ts`;
-        }
-    }
-    catch {
-        // A package with no readable manifest is read from its index, as the compiler reads it.
+    const manifest = manifestAt(host, dir);
+    const named = manifest?.["types"] ?? manifest?.["typings"];
+    if (typeof named === "string" && named !== "") {
+        const path = resolvePath(dir, named);
+        return path.endsWith(".ts") ? path : `${path}.d.ts`;
     }
     return joinPath(dir, "index.d.ts");
 }
@@ -146,14 +140,7 @@ export function automaticTypes(host, configFile, options, parse) {
     };
     const read = new Set();
     for (const root of typeRoots(configFile, options)) {
-        let entries;
-        try {
-            entries = host.readDirectory(root);
-        }
-        catch {
-            entries = [];
-        }
-        for (const entry of entries) {
+        for (const entry of entriesOf(host, root)) {
             if (read.has(entry.name) || host.kindOf(joinPath(root, entry.name)) !== "directory") {
                 continue;
             }
@@ -179,11 +166,5 @@ function typeRoots(configFile, options) {
     if (Array.isArray(listed)) {
         return listed.filter((root) => typeof root === "string" && root.endsWith(`/${TYPE_ROOT}`));
     }
-    const roots = [];
-    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
-        roots.push(joinPath(dir, TYPE_ROOT));
-        if (dirnamePath(dir) === dir) {
-            return roots;
-        }
-    }
+    return ancestors(dirnamePath(configFile)).map((dir) => joinPath(dir, TYPE_ROOT));
 }

package/dist/src/bindings.js

@@ -0,0 +1,382 @@
+/**
+ * The binding identities of the facts document, `bindings.6` and `bindings.7`: the consumer
+ * records a generator row's output names, read from the syntax its plugin writes, and the
+ * fallback records of the rows that bind a file only as a whole. The run publishes no state,
+ * so every record is an identity (`bindings.10`).
+ */
+import { isAsExpression, isEnumDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isJSDocText, isLiteralTypeNode, isMethodSignatureDeclaration, isObjectLiteralExpression, isParenthesizedTypeNode, isPropertyAssignment, isPropertySignatureDeclaration, isSatisfiesExpression, isStringLiteralLikeNode, isTypeAliasDeclaration, isTypeLiteralNode, isTypeReferenceNode, isUnionTypeNode, isVariableStatement, } from "@typescript/native/ast";
+import { GENERATORS } from "./contract/contract.generated.js";
+import { componentOf, nameNodeOf } from "./inventory.js";
+import { nameComponent, spell } from "./ref.js";
+import { bytewise } from "./text/compare.js";
+/** The `@generated from <kind> <rest>` tags of one node's own documentation, in order. */
+function generatedTags(node) {
+    const docs = node.jsDoc ?? [];
+    return docs.flatMap((doc) => (doc.tags ?? []).flatMap((tag) => {
+        const { tagName, comment } = tag;
+        if (tagName === undefined || !isIdentifier(tagName) || tagName.text !== "generated") {
+            return [];
+        }
+        const text = (comment ?? [])
+            .map((part) => (isJSDocText(part) ? part.text : ""))
+            .join("")
+            .trim();
+        const found = /^from (\w+(?: value)?):? (.+)$/u.exec(text);
+        return found === null ? [] : [{ kind: found[1] ?? "", rest: (found[2] ?? "").trim() }];
+    }));
+}
+/** The tag of one kind a node carries, its text after the kind. */
+function tagged(node, kind) {
+    return generatedTags(node).find((one) => one.kind === kind)?.rest;
+}
+/**
+ * The name a field or an enum value tag declares: the word before ` = <number>`, read
+ * before an optional bracketed option list (`= 7 [json_name = "sync"];`).
+ */
+function declaredName(rest) {
+    return /(\w+) = \d+(?: \[.*\])?;$/u.exec(rest)?.[1];
+}
+/** The spelled component of one declaration's name, or undefined for a name the grammar cannot spell. */
+function spelledName(node) {
+    const component = componentOf(nameNodeOf(node));
+    return component === undefined ? undefined : spell(component);
+}
+/** The object type literals one type is or holds as a direct constituent of a union or an intersection. */
+function literalsOf(type) {
+    if (type === undefined) {
+        return [];
+    }
+    if (isParenthesizedTypeNode(type)) {
+        return literalsOf(type.type);
+    }
+    if (isUnionTypeNode(type) || isIntersectionTypeNode(type)) {
+        return type.types.flatMap((one) => literalsOf(one));
+    }
+    return isTypeLiteralNode(type) ? [type] : [];
+}
+/** The string literal type one type literal declares for its `case` property, the oneof discriminant. */
+function caseOf(literal) {
+    if (!isTypeLiteralNode(literal)) {
+        return undefined;
+    }
+    for (const member of literal.members) {
+        if (isPropertySignatureDeclaration(member) &&
+            spelledName(member) === "case" &&
+            isLiteralTypeNode(member.type) &&
+            isStringLiteralLikeNode(member.type.literal)) {
+            return member.type.literal.text;
+        }
+    }
+    return undefined;
+}
+/** The fields, enum values and oneof constituents of one tagged message or enum, below its fragment. */
+function membersOf(members, fragment, name) {
+    return members.flatMap((member) => {
+        const spelled = spelledName(member);
+        if (spelled === undefined) {
+            return [];
+        }
+        const at = `${fragment}.${spelled}`;
+        const field = tagged(member, "field") ?? tagged(member, "enum value");
+        const declared = field === undefined ? undefined : declaredName(field);
+        if (declared !== undefined) {
+            return [{ fragment: at, name: `${name}.${declared}` }];
+        }
+        if (tagged(member, "oneof") === undefined || !isPropertySignatureDeclaration(member)) {
+            return [];
+        }
+        return literalsOf(member.type).flatMap((constituent) => {
+            const discriminant = caseOf(constituent);
+            return discriminant === undefined
+                ? []
+                : [
+                    {
+                        fragment: `${at}.'${discriminant.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}':case`,
+                        name: `${name}.${discriminant}`,
+                    },
+                ];
+        });
+    });
+}
+/** The full name `@generated from <kind> <pkg.Name>` gives, without a trailing comment. */
+function fullName(rest) {
+    return rest.split(/\s/u)[0] ?? rest;
+}
+/** The consumers a protoc-gen-es file of row `protoc-gen-es-2` names, as `references-ts.28` reads them. */
+function protobufEsConsumers(file) {
+    const found = [];
+    const typed = new Map();
+    const constants = [];
+    for (const statement of file.statements) {
+        if (isTypeAliasDeclaration(statement) || isInterfaceDeclaration(statement)) {
+            const fragment = spelledName(statement);
+            const message = tagged(statement, "message");
+            if (fragment === undefined || message === undefined) {
+                continue;
+            }
+            const name = fullName(message);
+            typed.set(statement.name.text, name);
+            found.push({ fragment, name });
+            const members = isInterfaceDeclaration(statement)
+                ? statement.members
+                : literalsOf(statement.type).flatMap((one) => (isTypeLiteralNode(one) ? one.members : []));
+            found.push(...membersOf(members, fragment, name));
+        }
+        else if (isEnumDeclaration(statement)) {
+            const fragment = spelledName(statement);
+            const enumName = tagged(statement, "enum");
+            if (fragment === undefined || enumName === undefined) {
+                continue;
+            }
+            const name = fullName(enumName);
+            typed.set(statement.name.text, name);
+            found.push({ fragment, name }, ...membersOf(statement.members, fragment, name));
+        }
+        else if (isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                const fragment = spelledName(declaration);
+                if (fragment === undefined) {
+                    continue;
+                }
+                const tags = [...generatedTags(statement), ...generatedTags(declaration)];
+                const enumName = tags.find((one) => one.kind === "enum")?.rest;
+                const service = tags.find((one) => one.kind === "service")?.rest;
+                const initializer = declaration.initializer;
+                const object = initializer === undefined ? undefined : asConst(initializer);
+                if (enumName !== undefined && object !== undefined && isObjectLiteralExpression(object)) {
+                    const name = fullName(enumName);
+                    typed.set(fragment, name);
+                    found.push({ fragment, name }, ...membersOf(object.properties, fragment, name));
+                }
+                else if (service !== undefined) {
+                    found.push({ fragment, name: fullName(service) });
+                    const [methods] = typeArguments(declaration.type);
+                    for (const literal of literalsOf(methods)) {
+                        for (const member of isTypeLiteralNode(literal) ? literal.members : []) {
+                            const spelled = spelledName(member);
+                            const rpc = tagged(member, "rpc");
+                            if (spelled !== undefined && rpc !== undefined) {
+                                found.push({ fragment: `${fragment}.${spelled}`, name: fullName(rpc) });
+                            }
+                        }
+                    }
+                }
+                else if (declaration.type !== undefined) {
+                    constants.push({ fragment, type: declaration.type, node: declaration });
+                }
+            }
+        }
+    }
+    for (const constant of constants) {
+        const type = constant.type;
+        if (!isTypeReferenceNode(type) || !isIdentifier(type.typeName)) {
+            continue;
+        }
+        if (type.typeName.text !== "GenMessage" && type.typeName.text !== "GenEnum") {
+            continue;
+        }
+        const [argument] = typeArguments(type);
+        const named = argument !== undefined && isTypeReferenceNode(argument) && isIdentifier(argument.typeName)
+            ? typed.get(argument.typeName.text)
+            : undefined;
+        if (named !== undefined) {
+            found.push({ fragment: constant.fragment, name: named });
+        }
+    }
+    return found;
+}
+/** The expression an `as const` or `satisfies` clause holds, or the expression itself. */
+function asConst(node) {
+    return isAsExpression(node) || isSatisfiesExpression(node) ? asConst(node.expression) : node;
+}
+/** The type arguments one type reference writes. */
+function typeArguments(type) {
+    return type !== undefined && isTypeReferenceNode(type) ? (type.typeArguments ?? []) : [];
+}
+/** A ts-proto service path literal, split into its service and its method. */
+const SERVICE_PATH = /^\/((?:\w+\.)*\w+)\/(\w+)$/u;
+/**
+ * The service and RPC consumers a ts-proto file of row `ts-proto-2` names, as
+ * `references-ts.31` reads them: the methods of the interface a `<Svc>ServiceName`
+ * constant names, and a definition object whose members write a service `path`, with each
+ * member the consumer of its RPC and the object, and the `<Svc>Client` that the same
+ * file declares beside it, consumers of the service.
+ */
+function tsProtoConsumers(file) {
+    const found = [];
+    const interfaces = new Map();
+    const clients = new Set();
+    for (const statement of file.statements) {
+        if (isInterfaceDeclaration(statement)) {
+            interfaces.set(statement.name.text, statement.members);
+        }
+        if (isVariableStatement(statement)) {
+            for (const one of statement.declarationList.declarations) {
+                if (isIdentifier(one.name)) {
+                    clients.add(one.name.text);
+                }
+            }
+        }
+    }
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const { name, initializer } = declaration;
+            if (!isIdentifier(name) || initializer === undefined) {
+                continue;
+            }
+            if (name.text.endsWith("ServiceName") && isStringLiteralLikeNode(initializer)) {
+                const service = name.text.slice(0, -"ServiceName".length);
+                for (const member of interfaces.get(service) ?? []) {
+                    const spelled = spelledName(member);
+                    if (spelled !== undefined && isMethodSignatureDeclaration(member)) {
+                        found.push({
+                            fragment: `${nameComponent(service)}.${spelled}`,
+                            name: `${initializer.text}.${spelled}`,
+                        });
+                    }
+                }
+                continue;
+            }
+            const object = asConst(initializer);
+            if (!isObjectLiteralExpression(object)) {
+                continue;
+            }
+            let service;
+            for (const property of object.properties) {
+                const spelled = spelledName(property);
+                const value = isPropertyAssignment(property) ? asConst(property.initializer) : undefined;
+                const path = value !== undefined && isObjectLiteralExpression(value)
+                    ? value.properties.find((one) => isPropertyAssignment(one) &&
+                        spelledName(one) === "path" &&
+                        isStringLiteralLikeNode(one.initializer))
+                    : undefined;
+                const matched = path !== undefined &&
+                    isPropertyAssignment(path) &&
+                    isStringLiteralLikeNode(path.initializer)
+                    ? SERVICE_PATH.exec(path.initializer.text)
+                    : null;
+                if (spelled === undefined || matched === null) {
+                    continue;
+                }
+                service = matched[1];
+                const rpc = `${matched[1] ?? ""}.${matched[2] ?? ""}`;
+                found.push({ fragment: `${nameComponent(name.text)}.${spelled}`, name: rpc });
+                const client = `${name.text.replace(/Service$/u, "")}Client`;
+                if (interfaces.get(client)?.some((member) => spelledName(member) === spelled) === true) {
+                    found.push({ fragment: `${nameComponent(client)}.${spelled}`, name: rpc });
+                }
+            }
+            if (service !== undefined) {
+                found.push({ fragment: nameComponent(name.text), name: service });
+                const client = `${name.text.replace(/Service$/u, "")}Client`;
+                if (interfaces.has(client) || clients.has(client)) {
+                    found.push({ fragment: nameComponent(client), name: service });
+                }
+            }
+        }
+    }
+    return found;
+}
+/** The package `// @generated from file <path> (package <pkg>, ...)` or `protobufPackage` names, `.` for none. */
+function packageOf(file) {
+    const header = /^\/\/ @generated from file \S+ \(package ([\w.]+)/mu.exec(file.text)?.[1];
+    if (header !== undefined) {
+        return header;
+    }
+    for (const statement of file.statements) {
+        if (!isVariableStatement(statement)) {
+            continue;
+        }
+        for (const one of statement.declarationList.declarations) {
+            if (isIdentifier(one.name) &&
+                one.name.text === "protobufPackage" &&
+                one.initializer !== undefined &&
+                isStringLiteralLikeNode(one.initializer) &&
+                one.initializer.text !== "") {
+                return one.initializer.text;
+            }
+        }
+    }
+    return ".";
+}
+/** The `proto://` reference of a schema declaration a full name written in package `pkg` names. */
+function schemaRef(pkg, name) {
+    const local = pkg !== "." && name.startsWith(`${pkg}.`) ? name.slice(pkg.length + 1) : name;
+    return `proto://${pkg}#${local}`;
+}
+/** The consumer reader of each row whose output the analyzer decodes. */
+const CONSUMERS = {
+    "protoc-gen-es-2": protobufEsConsumers,
+    "ts-proto-2": tsProtoConsumers,
+};
+/** The scope of the fallback record each fallback cell publishes. */
+const FALLBACK_SCOPE = {
+    fallback: "all",
+    "rpc-types-fallback": "types",
+};
+/**
+ * The binding records one project's generated files publish, each file read once:
+ * `files` by path below the target root, `moduleRefs` each file's own reference.
+ */
+export function bindingsOf(files, generated, moduleRefs) {
+    const records = [];
+    for (const [path, fact] of generated) {
+        const file = files.get(path);
+        const moduleRef = moduleRefs.get(path);
+        const generator = fact.generator;
+        if (file === undefined || moduleRef === undefined || generator === undefined) {
+            continue;
+        }
+        const [schemaFile] = generator.schemaFiles;
+        const cell = GENERATORS.find((row) => row.id === generator.row)?.cell;
+        const scope = cell === undefined ? undefined : FALLBACK_SCOPE[cell];
+        if (scope !== undefined) {
+            for (const one of generator.schemaFiles) {
+                records.push({
+                    role: "fallback",
+                    symbol: moduleRef,
+                    schema_file: one,
+                    generated_file: path,
+                    scope,
+                    state: "live",
+                });
+            }
+        }
+        const read = CONSUMERS[generator.row];
+        if (read === undefined || schemaFile === undefined) {
+            continue;
+        }
+        const pkg = packageOf(file);
+        const seen = new Set();
+        for (const named of read(file)) {
+            const symbol = `${moduleRef}${named.fragment}`;
+            if (seen.has(symbol)) {
+                continue;
+            }
+            seen.add(symbol);
+            records.push({
+                role: "consumer",
+                symbol,
+                schema_file: schemaFile,
+                schema: schemaRef(pkg, named.name),
+                generated_file: path,
+            });
+        }
+    }
+    return records;
+}
+/**
+ * The records of a run's projects, each once, in the order the facts schema states: by
+ * schema file, schema, role and symbol. A generated file two projects hold publishes its
+ * records in each.
+ */
+export function distinctBindings(records) {
+    const byKey = new Map(records.map((one) => [JSON.stringify(one), one]));
+    return [...byKey.values()].sort((a, b) => bytewise(a.schema_file, b.schema_file) ||
+        bytewise(a.schema ?? "", b.schema ?? "") ||
+        bytewise(a.role, b.role) ||
+        bytewise(a.symbol, b.symbol));
+}