@cplieger/deadset-ts 3.3.1 → 3.5.0

package/dist/src/configured-declarations.js

@@ -0,0 +1,232 @@
+/**
+ * The declarations the configuration's entries name, resolved in one project, and
+ * which of them a symbol is. Declarations are compared rather than symbols, because a
+ * member read through an instantiation of a generic type is a symbol of its own that
+ * keeps the declarations of the member it instantiates.
+ */
+import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SymbolFlags, } from "@typescript/native/unstable/sync";
+import { resolvedTargets } from "./calls.js";
+import { nameComponent } from "./ref.js";
+/** The meanings a name of the global scope is looked up under: any of them. */
+const ANY_MEANING = SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace;
+/** The suffix that marks a static member at the end of a path. */
+const STATIC = ":static";
+/** The key one declaration handle is compared by: its file and its index in that file. */
+function handleKey(handle) {
+    return `${handle.path}:${String(handle.index)}`;
+}
+/**
+ * The components of one declaration path and whether its last one is a static member.
+ * A path is split at the dots outside a quoted or a bracketed component, and each
+ * component keeps the spelling a reference gives it.
+ */
+function componentsOf(path) {
+    const isStatic = path.endsWith(STATIC);
+    const body = isStatic ? path.slice(0, -STATIC.length) : path;
+    const components = [];
+    let current = "";
+    let closing = "";
+    for (let at = 0; at < body.length; at += 1) {
+        const ch = body.charAt(at);
+        if (closing === "'" && ch === "\\") {
+            current += ch + body.charAt(at + 1);
+            at += 1;
+            continue;
+        }
+        if (closing !== "") {
+            closing = ch === closing ? "" : closing;
+        }
+        else if (ch === "'" || ch === "[") {
+            closing = ch === "'" ? "'" : "]";
+        }
+        else if (ch === ".") {
+            components.push(current);
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    components.push(current);
+    return { components, static: isStatic };
+}
+/** What a symbol is once every alias it stands for is followed. */
+function unaliased(project, symbol) {
+    if ((symbol.flags & SymbolFlags.Alias) === 0) {
+        return symbol;
+    }
+    const target = project.checker.getAliasedSymbol(symbol);
+    return target.declarations.length === 0 ? undefined : target;
+}
+/** Whether one symbol is a member a class declares: a property, a method or an accessor. */
+function isClassMember(symbol) {
+    return (symbol.flags & SymbolFlags.ClassMember) !== 0;
+}
+/**
+ * The members of one container a path component may name. A class keeps its static
+ * members among its exports beside what a merged namespace exports, so a component
+ * with the static suffix names one of the first and a component without it names an
+ * instance member or one of the second.
+ */
+function candidatesOf(container, isStatic) {
+    const exported = [...container.getExports().values()];
+    if (isStatic) {
+        return exported.filter(isClassMember);
+    }
+    const isClass = (container.flags & SymbolFlags.Class) !== 0;
+    return [
+        ...container.getMembers().values(),
+        ...exported.filter((member) => !isClass || !isClassMember(member)),
+    ];
+}
+/** The member of one container a path component spells, followed through any alias. */
+function memberOf(project, container, component, isStatic) {
+    const member = candidatesOf(container, isStatic).find((candidate) => nameComponent(candidate.name) === component);
+    return member === undefined ? undefined : unaliased(project, member);
+}
+/** The declaration a path names from one starting symbol, component by component. */
+function walkPath(project, start, rest, isStatic) {
+    let at = start;
+    rest.forEach((component, index) => {
+        if (at !== undefined) {
+            at = memberOf(project, at, component, isStatic && index === rest.length - 1);
+        }
+    });
+    return at;
+}
+/** Whether one node is literal text: a string literal or a template with no substitution. */
+function isLiteralText(node) {
+    return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
+}
+/** The module specifier one node writes, for each form that imports or re-exports a module. */
+function specifierOf(node) {
+    if (isImportDeclaration(node) || isExportDeclaration(node)) {
+        return node.moduleSpecifier;
+    }
+    if (isImportEqualsDeclaration(node) && isExternalModuleReference(node.moduleReference)) {
+        return node.moduleReference.expression;
+    }
+    if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
+        return node.arguments[0];
+    }
+    return undefined;
+}
+/**
+ * The module each specifier the entries name resolves to in one project, read from a
+ * specifier the project's own files write, so the module is the one the target's own
+ * import resolves. A specifier no file writes resolves to no module.
+ */
+function modulesNamed(project, specifiers) {
+    const written = new Map();
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            const specifier = specifierOf(node);
+            if (isLiteralText(specifier) &&
+                specifiers.has(specifier.text) &&
+                !written.has(specifier.text)) {
+                written.set(specifier.text, specifier);
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    const specified = [...written];
+    const symbols = project.symbolsAt(specified.map(([, node]) => project.handle(node)));
+    const modules = new Map();
+    specified.forEach(([name], index) => {
+        const symbol = symbols[index];
+        if (symbol !== undefined) {
+            modules.set(name, symbol);
+        }
+    });
+    return modules;
+}
+/**
+ * The declaration each entry names in one project. A symbol entry names the
+ * inventory's declaration whose reference it spells exactly; a module entry names the
+ * declaration its path reaches from the exports of the module its specifier resolves
+ * to; a global entry names the declaration its path reaches from the global scope.
+ * Every alias along a path is followed to the declaration it stands for.
+ */
+export function resolveEntries(project, held, entries) {
+    if (entries.length === 0) {
+        return [];
+    }
+    const byRef = new Map(held.symbols.map((symbol) => [symbol.ref, symbol.id]));
+    const modules = modulesNamed(project, new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))));
+    return entries.map((entry) => {
+        if (entry.shape === "symbol") {
+            const id = byRef.get(entry.symbol);
+            return { entry, handles: new Set(), ids: new Set(id === undefined ? [] : [id]) };
+        }
+        const { components, static: isStatic } = componentsOf(entry.shape === "module" ? entry.name : entry.global);
+        const [first = "", ...rest] = components;
+        let start;
+        if (isStatic && rest.length === 0) {
+            // Only a member is static, and a path of one component names no member.
+            start = undefined;
+        }
+        else if (entry.shape === "module") {
+            const module = modules.get(entry.module);
+            start = module === undefined ? undefined : memberOf(project, module, first, false);
+        }
+        else if (nameComponent(first) === first) {
+            const global = project.checker.resolveName(first, ANY_MEANING, undefined, false);
+            start = global === undefined ? undefined : unaliased(project, global);
+        }
+        const declared = walkPath(project, start, rest, isStatic);
+        return {
+            entry,
+            handles: new Set(declared?.declarations.map(handleKey) ?? []),
+            ids: new Set(),
+        };
+    });
+}
+/**
+ * Whether one symbol is the declaration a resolved entry names: it shares one of the
+ * entry's declarations, or, for an entry naming a declaration of the program, it is
+ * declared there. `chains` reads the symbol's declarations against the inventory the
+ * entries were resolved with.
+ */
+export function names(resolved, symbol, chains) {
+    if (symbol.declarations.some((handle) => resolved.handles.has(handleKey(handle)))) {
+        return true;
+    }
+    return resolved.ids.size > 0 && chains.declarationsOf(symbol).some((id) => resolved.ids.has(id));
+}
+/** Whether a resolved entry names a declaration, so that some symbol can be it. */
+export function namesADeclaration(resolved) {
+    return resolved.handles.size > 0 || resolved.ids.size > 0;
+}
+/**
+ * The entries each of a batch of name nodes is: what the node resolves to, every alias
+ * followed, is the declaration each of them names. A node that is none is absent.
+ */
+export function entriesAt(project, chains, nodes, resolved) {
+    const naming = resolved.filter(namesADeclaration);
+    const found = new Map();
+    if (naming.length === 0) {
+        return found;
+    }
+    for (const [node, target] of resolvedTargets(project, nodes)) {
+        const entries = naming.filter((entry) => names(entry, target, chains));
+        if (entries.length > 0) {
+            found.set(node, entries);
+        }
+    }
+    return found;
+}
+/**
+ * How one entry is spelled in a record's detail: its path, or for a declaration of the
+ * program the display name the inventory gives it.
+ */
+export function spelledEntry(entry, held) {
+    switch (entry.shape) {
+        case "symbol":
+            return held.symbols.find((symbol) => symbol.ref === entry.symbol)?.name ?? entry.symbol;
+        case "module":
+            return entry.name;
+        case "global":
+            return entry.global;
+    }
+}

package/dist/src/decorator.js

@@ -10,17 +10,11 @@
  * declaration is held back, and the member set of a decorated class is every member
  * the inventory holds for the class, static members included.
  */
-import { isCallExpression, isDecorator, } from "@typescript/native/unstable/ast";
+import { decoratorsOf, spelledDecorator } from "./calls.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 /** The kinds of declaration a decorator is attached to and holds back. */
 const DECORATED = new Set(["class", "method", "class-member"]);
-/** How one decorator is spelled in a record: its expression, without a call's arguments. */
-function spelled(decorator) {
-    const expression = decorator.expression;
-    const named = isCallExpression(expression) ? expression.expression : expression;
-    return `@${named.getText().replace(/\s+/gu, "")}`;
-}
 /**
  * The decorator detector: each decorated member, and each member of a decorated
  * class, recorded at the decorator.
@@ -46,9 +40,8 @@ export function decorator(input) {
             const id = held.declarations.get(nodeKey(file, node));
             const symbol = id === undefined ? undefined : byId.get(id);
             if (symbol !== undefined && DECORATED.has(symbol.kind)) {
-                const modifiers = node.modifiers ?? [];
-                for (const attached of modifiers.filter(isDecorator)) {
-                    const detail = `decorated by ${spelled(attached)}`;
+                for (const attached of decoratorsOf(node)) {
+                    const detail = `decorated by ${spelledDecorator(attached)}`;
                     const site = renderPosition(file, targetRoot, attached.getStart());
                     const reached = symbol.kind === "class" ? (membersOf.get(symbol.id) ?? []) : [symbol];
                     for (const member of reached) {

package/dist/src/framework-lifecycle.js

@@ -0,0 +1,192 @@
+/**
+ * The framework-lifecycle class: a member a `ts.lifecycle_contracts` entry lists is held
+ * back on each class that is the entry's component, being a class a decorator or a call
+ * the entry's `components` name is attached to or passes, or one extending, directly or
+ * through a chain, a class its `bases` name. A component's members are its type's, so a
+ * member a base class declares answers for every subclass.
+ */
+import { isClassDeclaration, isClassExpression, isHeritageClause, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { aliasChains } from "./alias-chain.js";
+import { calleeName, callsOf, classesPassed, decoratedClasses, decoratorCallee } from "./calls.js";
+import { classMembers, memberComponent, typesAt } from "./class-members.js";
+import { entriesAt, names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+/** Every contract's components and bases, resolved in one pass over the entries. */
+function resolveContracts(project, held, contracts) {
+    const entries = contracts.flatMap((contract) => [
+        ...contract.components,
+        ...contract.bases,
+    ]);
+    const resolved = resolveEntries(project, held, entries);
+    let next = 0;
+    const take = (count) => {
+        const taken = resolved.slice(next, next + count).filter(namesADeclaration);
+        next += count;
+        return taken;
+    };
+    return contracts.map((contract) => ({
+        contract,
+        components: take(contract.components.length),
+        bases: take(contract.bases.length),
+    }));
+}
+/** The classes a decorator or a call the contracts' components name makes a component. */
+function byComponents(project, held, chains, contracts) {
+    const routed = contracts.filter((one) => one.components.length > 0);
+    if (routed.length === 0) {
+        return [];
+    }
+    const contractOf = new Map(routed.flatMap((one) => one.components.map((entry) => [entry, one.contract])));
+    const calls = callsOf(project);
+    const decorated = decoratedClasses(project, held);
+    const named = entriesAt(project, chains, [
+        ...calls.flatMap((call) => calleeName(call.expression) ?? []),
+        ...decorated.flatMap((one) => one.decorators.flatMap((decorator) => decoratorCallee(decorator) ?? [])),
+    ], [...contractOf.keys()]);
+    const naming = (node) => (node === undefined ? [] : (named.get(node) ?? [])).flatMap((entry) => {
+        const contract = contractOf.get(entry);
+        return contract === undefined ? [] : [{ contract, detail: spelledEntry(entry.entry, held) }];
+    });
+    const found = [];
+    for (const one of decorated) {
+        for (const decorator of one.decorators) {
+            for (const { contract, detail } of naming(decoratorCallee(decorator))) {
+                found.push({ contract, id: one.id, site: decorator, detail: `decorated by @${detail}` });
+            }
+        }
+    }
+    const matched = new Map();
+    for (const call of calls) {
+        const routes = naming(calleeName(call.expression));
+        if (routes.length > 0) {
+            matched.set(call, routes);
+        }
+    }
+    for (const [call, uses] of classesPassed(project, held, chains, [...matched.keys()])) {
+        for (const route of matched.get(call) ?? []) {
+            for (const use of uses) {
+                found.push({
+                    contract: route.contract,
+                    id: use.id,
+                    site: use.site,
+                    detail: `registered by ${route.detail}`,
+                });
+            }
+        }
+    }
+    return found;
+}
+/** The class declarations of the target that extend another class. */
+function extendingClasses(project, held) {
+    const found = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            if ((isClassDeclaration(node) || isClassExpression(node)) && node.name !== undefined) {
+                const id = held.declarations.get(nodeKey(file, node));
+                const clause = (node.heritageClauses ?? []).find((one) => isHeritageClause(one) && one.token === SyntaxKind.ExtendsKeyword);
+                const extended = clause !== undefined && isHeritageClause(clause) ? clause.types[0] : undefined;
+                if (id !== undefined && extended !== undefined) {
+                    found.push({ id, name: node.name, extended });
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    return found;
+}
+/** The classes that extend, directly or through a chain, a class the contracts' bases name. */
+function byBases(project, held, chains, contracts) {
+    const based = contracts.filter((one) => one.bases.length > 0);
+    if (based.length === 0) {
+        return [];
+    }
+    const classes = extendingClasses(project, held);
+    if (classes.length === 0) {
+        return [];
+    }
+    const checker = project.checker;
+    const ancestry = new Map();
+    const ancestorsOf = (type, seen) => {
+        const known = ancestry.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const declared = type.isClassOrInterface()
+            ? type
+            : type.isTypeReference()
+                ? type.getTarget()
+                : undefined;
+        if (declared === undefined || !declared.isClassOrInterface() || seen.has(declared.id)) {
+            return [];
+        }
+        seen.add(declared.id);
+        const found = checker
+            .getBaseTypes(declared)
+            .flatMap((base) => [base, ...ancestorsOf(base, seen)]);
+        ancestry.set(type.id, found);
+        return found;
+    };
+    const types = typesAt(project, classes.map((one) => one.name));
+    const found = [];
+    classes.forEach((one, index) => {
+        const type = types[index];
+        if (type === undefined) {
+            return;
+        }
+        const ancestors = ancestorsOf(type, new Set()).flatMap((base) => base.getSymbol() ?? []);
+        for (const contract of based) {
+            for (const entry of contract.bases) {
+                if (ancestors.some((symbol) => names(entry, symbol, chains))) {
+                    found.push({
+                        contract: contract.contract,
+                        id: one.id,
+                        site: one.extended,
+                        detail: `extends ${spelledEntry(entry.entry, held)}`,
+                    });
+                }
+            }
+        }
+    });
+    return found;
+}
+/**
+ * The framework-lifecycle detector: each member a contract lists, on each class that
+ * is a component of that contract's framework, recorded where the class was found to
+ * be one.
+ */
+export function frameworkLifecycle(input) {
+    const { project, held, targetRoot } = input;
+    if (input.ts.lifecycleContracts.length === 0) {
+        return [];
+    }
+    const chains = aliasChains(project, held);
+    const contracts = resolveContracts(project, held, input.ts.lifecycleContracts);
+    const components = [
+        ...byComponents(project, held, chains, contracts),
+        ...byBases(project, held, chains, contracts),
+    ];
+    if (components.length === 0) {
+        return [];
+    }
+    const ids = new Set(components.map((one) => one.id));
+    const sides = input.ts.lifecycleContracts.some((contract) => contract.members.some((name) => name.endsWith(":static")))
+        ? ["instance", "static"]
+        : ["instance"];
+    const members = sides.map((side) => classMembers(project, held, ids, side));
+    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+    const found = [];
+    for (const component of components) {
+        const listed = new Set(component.contract.members);
+        const site = renderPosition(component.site.getSourceFile(), targetRoot, component.site.getStart());
+        for (const member of members.flatMap((side) => side.get(component.id) ?? [])) {
+            const symbol = byId.get(member.id);
+            const spelled = symbol === undefined ? undefined : memberComponent(symbol, byId);
+            if (spelled !== undefined && listed.has(spelled)) {
+                found.push({ id: member.id, detail: component.detail, site });
+            }
+        }
+    }
+    return found;
+}

package/dist/src/injection-container.js

@@ -0,0 +1,101 @@
+/**
+ * The injection-container class: a container constructs a class passed to a call
+ * `ts.injection_registrations` names, or one a parameter of whose constructor carries a
+ * decorator, and populates each of its properties and accessors that carries one, a base
+ * class's included. A constructor and its parameters are no declarations of the
+ * inventory, so the class stands for them and the registration referencing it keeps it.
+ */
+import { isClassDeclaration, isClassExpression, isConstructorDeclaration, isGetAccessorDeclaration, isPropertyDeclaration, isSetAccessorDeclaration, } from "@typescript/native/unstable/ast";
+import { aliasChains } from "./alias-chain.js";
+import { calleeName, callsOf, classesPassed, decoratorsOf, spelledDecorator } from "./calls.js";
+import { classMembers } from "./class-members.js";
+import { entriesAt, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+/** Whether one member declaration is a property or an accessor carrying a decorator. */
+function isInjected(node) {
+    return ((isPropertyDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node)) &&
+        decoratorsOf(node).length > 0);
+}
+/** The classes of the target a call whose callee an entry names passes, with that call's entry. */
+function registrations(input) {
+    const { project, held } = input;
+    const resolved = resolveEntries(project, held, input.ts.injectionRegistrations);
+    if (!resolved.some(namesADeclaration)) {
+        return [];
+    }
+    const chains = aliasChains(project, held);
+    const calls = callsOf(project);
+    const named = entriesAt(project, chains, calls.flatMap((call) => calleeName(call.expression) ?? []), resolved);
+    const matched = new Map();
+    for (const call of calls) {
+        const name = calleeName(call.expression);
+        const [entry] = name === undefined ? [] : (named.get(name) ?? []);
+        if (entry !== undefined) {
+            matched.set(call, entry);
+        }
+    }
+    return [...classesPassed(project, held, chains, [...matched.keys()])].flatMap(([call, uses]) => {
+        const entry = matched.get(call);
+        const detail = entry === undefined ? "" : `registered by ${spelledEntry(entry.entry, held)}`;
+        return uses.map((use) => ({ id: use.id, site: use.site, detail }));
+    });
+}
+/** The classes of the target a parameter of whose constructor carries a decorator. */
+function constructedForParameters(input) {
+    const { project, held } = input;
+    const found = new Set();
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            if (isClassDeclaration(node) || isClassExpression(node)) {
+                const id = held.declarations.get(nodeKey(file, node));
+                const asks = node.members.some((member) => isConstructorDeclaration(member) &&
+                    member.parameters.some((parameter) => decoratorsOf(parameter).length > 0));
+                if (id !== undefined && asks) {
+                    found.add(id);
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    return found;
+}
+/**
+ * The injection-container detector: each decorated property or accessor of a class a
+ * container constructs, recorded at the registration that names the class, or, for a
+ * class whose constructor asks for its parameters, at the member's own decorator.
+ */
+export function injectionContainer(input) {
+    const { project, held, targetRoot } = input;
+    const registered = registrations(input);
+    const constructed = constructedForParameters(input);
+    const classes = new Set([...registered.map((one) => one.id), ...constructed]);
+    if (classes.size === 0) {
+        return [];
+    }
+    const members = classMembers(project, held, classes, "instance");
+    const injected = (id) => (members.get(id) ?? []).filter((member) => isInjected(member.node));
+    const at = (node) => renderPosition(node.getSourceFile(), targetRoot, node.getStart());
+    const found = [];
+    for (const registration of registered) {
+        for (const member of injected(registration.id)) {
+            found.push({ id: member.id, detail: registration.detail, site: at(registration.site) });
+        }
+    }
+    for (const id of constructed) {
+        for (const member of injected(id)) {
+            const [decorator] = decoratorsOf(member.node);
+            if (decorator !== undefined) {
+                found.push({
+                    id: member.id,
+                    detail: `injected by ${spelledDecorator(decorator)}`,
+                    site: at(decorator),
+                });
+            }
+        }
+    }
+    return found;
+}

package/dist/src/kinds.js

@@ -10,3 +10,43 @@
  * code the Contract fixes arrives here as a failing test.
  */
 export const FIXED_SEVERITY_CODES = ["DS1703", "DS1704"];
+/**
+ * The code of every live issue kind, in ascending order. A severity key names one of
+ * them or a family prefix whose range holds one; a key naming a retired code, an
+ * unassigned code or a range holding no live kind is an unimplemented key, so every
+ * severity a configuration sets is one some analyzer reports under. A test compares
+ * this list against the Contract release the analyzer is written against.
+ */
+export const LIVE_CODES = [
+    "DS1001",
+    "DS1002",
+    "DS1003",
+    "DS1004",
+    "DS1005",
+    "DS1006",
+    "DS1101",
+    "DS1102",
+    "DS1103",
+    "DS1104",
+    "DS1201",
+    "DS1203",
+    "DS1204",
+    "DS1301",
+    "DS1302",
+    "DS1303",
+    "DS1501",
+    "DS1502",
+    "DS1601",
+    "DS1605",
+    "DS1701",
+    "DS1702",
+    "DS1703",
+    "DS1704",
+    "DS1705",
+    "DS1801",
+    "DS1802",
+    "DS1803",
+    "DS1805",
+    "DS1807",
+    "DS1809",
+];

package/dist/src/print.js

@@ -1,4 +1,23 @@
-import { renderOrigin } from "./config.js";
+import { renderOrigin, } from "./config.js";
+/** One declaration entry as a document writes it: the members of its shape alone. */
+function declarationOf(entry) {
+    switch (entry.shape) {
+        case "symbol":
+            return { symbol: entry.symbol };
+        case "module":
+            return { module: entry.module, name: entry.name };
+        case "global":
+            return { global: entry.global };
+    }
+}
+/** One provider entry as a document writes it: the members of its shape alone. */
+function providerOf(entry) {
+    const installed = { name: entry.name, languages: entry.languages, command: entry.command };
+    if (entry.shape === "installed") {
+        return installed;
+    }
+    return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
+}
 /**
  * The resolved configuration and its provenance as one JSON object, indented,
  * ending in a newline.
@@ -40,10 +59,18 @@ export function printConfig(config, provenance) {
             max_findings: config.reporters.maxFindings,
             fail_on: config.reporters.failOn,
         },
+        providers: { analyzers: config.providers.analyzers.map(providerOf) },
         go: {},
         ts: {
             test_files: config.ts.testFiles,
             entry_files: config.ts.entryFiles,
+            injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
+            lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
+                components: entry.components.map(declarationOf),
+                bases: entry.bases.map(declarationOf),
+                members: entry.members,
+            })),
+            serializers: config.ts.serializers.map(declarationOf),
         },
         provenance: Object.fromEntries([...provenance]
             .sort(([a], [b]) => (a < b ? -1 : 1))