@gtkx/codegen 0.21.0 → 1.0.0-rc.1

package/src/store/gi/record-layout.ts

@@ -0,0 +1,134 @@
+import type { GirField } from "../../gir/field.js";
+import {
+    computeFieldSlots,
+    type FieldLayout,
+    type FieldLayoutInput,
+    type FieldSlot,
+    layoutOfPrimitive,
+} from "../../gir/size.js";
+import type { EntityType, GirType } from "../../gir/type.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { ModuleContext } from "../../writer/context.js";
+
+const POINTER_LAYOUT: FieldLayout = { size: 8, align: 8 };
+
+export type RecordFieldSlot = {
+    field: GirField;
+    slot: FieldSlot;
+};
+
+export const computeRecordFieldSlots = (
+    context: ModuleContext,
+    fields: GirField[],
+    isUnion = false,
+): { slots: RecordFieldSlot[]; size: number } => {
+    const inputs: FieldLayoutInput[] = [];
+    for (const field of fields) {
+        inputs.push(fieldLayoutInput(context, field, new Set()));
+    }
+    const result = computeFieldSlots(inputs, isUnion);
+    const slots = result.slots.map((slot, index) => {
+        const field = fields[index];
+        if (field === undefined) {
+            throw new Error("computeRecordFieldSlots: parallel arrays diverged");
+        }
+        return { field, slot };
+    });
+    return { slots, size: result.size };
+};
+
+export const bitMask = (width: number): number => {
+    if (width >= 32) return 0xffffffff;
+    return (1 << width) - 1;
+};
+
+export const mergeBitfield = (readExpr: string, valueExpr: string, mask: number, shift: number): string =>
+    `((${readExpr} & ~(${mask} << ${shift})) | ((Number(${valueExpr}) & ${mask}) << ${shift})) >>> 0`;
+
+const fieldLayoutInput = (context: ModuleContext, field: GirField, visited: Set<string>): FieldLayoutInput => {
+    if (field.type === undefined) {
+        return { layout: POINTER_LAYOUT, bits: undefined };
+    }
+    return { layout: layoutOfType(context, field.type, field.cType, visited), bits: field.bits };
+};
+
+const layoutOfType = (
+    context: ModuleContext,
+    ref: TypeId,
+    occurrenceCType: string | undefined,
+    visited: Set<string>,
+): FieldLayout => {
+    const type = context.library.typeOf(ref);
+    if (type === undefined) return POINTER_LAYOUT;
+    switch (type.kind) {
+        case "primitive":
+            return layoutOfPrimitive(type.category);
+        case "carray":
+            return arrayLayout(context, type, visited);
+        case "list":
+        case "hashtable":
+        case "callback":
+        case "varargs":
+        case "class":
+        case "interface":
+            return POINTER_LAYOUT;
+        case "enum":
+            return occurrenceCType?.endsWith("*") === true ? POINTER_LAYOUT : layoutOfPrimitive("int32");
+        case "record":
+            return occurrenceCType?.endsWith("*") === true ? POINTER_LAYOUT : layoutOfRecord(context, type, visited);
+        case "alias":
+            return occurrenceCType?.endsWith("*") === true
+                ? POINTER_LAYOUT
+                : resolveAliasLayout(context, type, visited);
+    }
+};
+
+const arrayLayout = (
+    context: ModuleContext,
+    ref: Extract<GirType, { kind: "carray" }>,
+    visited: Set<string>,
+): FieldLayout => {
+    if (ref.fixedSize === undefined) return POINTER_LAYOUT;
+    const elementLayout = layoutOfType(context, ref.element, ref.elementCType, visited);
+    return { size: elementLayout.size * ref.fixedSize, align: elementLayout.align };
+};
+
+const layoutOfRecord = (
+    context: ModuleContext,
+    resolved: Extract<EntityType, { kind: "record" }>,
+    visited: Set<string>,
+): FieldLayout => {
+    if (resolved.value.cType?.endsWith("*") === true) return POINTER_LAYOUT;
+    const key = `${resolved.namespace.name}.${resolved.value.name}`;
+    if (visited.has(key)) return POINTER_LAYOUT;
+    const cached = recordLayoutCache.get(key);
+    if (cached !== undefined) return cached;
+    const nextVisited = new Set(visited);
+    nextVisited.add(key);
+    const inputs: FieldLayoutInput[] = [];
+    for (const field of resolved.value.fields) {
+        if (field.type === undefined) {
+            inputs.push({ layout: POINTER_LAYOUT, bits: undefined });
+            continue;
+        }
+        inputs.push({ layout: layoutOfType(context, field.type, field.cType, nextVisited), bits: field.bits });
+    }
+    if (inputs.length === 0) return POINTER_LAYOUT;
+    const { size } = computeFieldSlots(inputs, resolved.value.isUnion);
+    const align = Math.max(1, ...inputs.map((input) => input.layout.align));
+    const layout: FieldLayout = { size, align };
+    recordLayoutCache.set(key, layout);
+    return layout;
+};
+
+const recordLayoutCache = new Map<string, FieldLayout>();
+
+const resolveAliasLayout = (
+    context: ModuleContext,
+    resolved: Extract<EntityType, { kind: "alias" }>,
+    visited: Set<string>,
+): FieldLayout => {
+    const ref = resolved.value.target;
+    if (ref === undefined) return POINTER_LAYOUT;
+    return layoutOfType(context, ref, resolved.value.targetCType, visited);
+};

package/src/store/gi/record.ts

@@ -0,0 +1,66 @@
+import type { GirRecord } from "../../gir/record.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { indentMembers } from "../../writer/emit.js";
+import { type Callables, dedupeCallables, generateBindings, renderPlainTypeMembers } from "./callables.js";
+import { isClassStructRecord } from "./class-struct-record.js";
+import { gtypeExprFor } from "./gtype-binding.js";
+import { renderRecordConstructor, renderRecordConstructorPropsInterface } from "./record-constructor.js";
+import { renderRecordFieldAccessor } from "./record-field-accessor.js";
+import { computeRecordFieldSlots } from "./record-layout.js";
+import { appendWrapperClassRegistration } from "./registration.js";
+
+const isGErrorRecord = (context: ModuleContext, record: GirRecord): boolean =>
+    context.namespace.name === "GLib" && record.glibGetType === "g_error_get_type";
+
+export const generateRecord = (context: ModuleContext, record: GirRecord): void => {
+    if (!record.introspectable) return;
+    if (record.isVtable) return;
+    if (record.name.length === 0) return;
+    if (isClassStructRecord(context.library, context.namespace.name, record)) return;
+    const className = record.name;
+    const extendsError = isGErrorRecord(context, record);
+    const callables: Callables = {
+        constructors: dedupeCallables(record.constructors),
+        functions: dedupeCallables(record.functions),
+        methods: dedupeCallables(record.methods),
+    };
+    generateBindings(context, callables);
+
+    const members = renderRecordMembers(context, record, className, callables);
+    const body = indentMembers(members);
+    const heritage = extendsError ? " extends globalThis.Error" : "";
+    context.module.appendDeclaration(`${renderJsDoc(record.doc)}export class ${className}${heritage} {\n${body}\n}`);
+    context.module.appendDeclaration(renderRecordConstructorPropsInterface(context, record, className));
+
+    const gtypeExpr = gtypeExprFor(context, record);
+    appendWrapperClassRegistration(context, {
+        className,
+        gtypeExpr,
+    });
+};
+
+const renderRecordMembers = (
+    context: ModuleContext,
+    record: GirRecord,
+    className: string,
+    callables: Callables,
+): string[] => {
+    const extendsError = isGErrorRecord(context, record);
+    const { members, claimedNames } = renderPlainTypeMembers({
+        context,
+        className,
+        callables,
+        hasGtype: record.glibGetType !== undefined,
+    });
+    members.unshift(renderRecordConstructor(context, record, className, extendsError));
+    const { slots } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+    for (const slot of slots) {
+        const block = renderRecordFieldAccessor(context, slot, claimedNames, record.fields);
+        if (block !== undefined) members.push(block);
+    }
+    if (extendsError) {
+        members.push('get name(): string {\n    return "GLib.Error";\n}');
+    }
+    return members;
+};

package/src/store/gi/registration.ts

@@ -0,0 +1,38 @@
+import type { ModuleContext } from "../../writer/context.js";
+
+type WrapperClassRegistration = {
+    className: string;
+    gtypeExpr?: string | undefined;
+    vfuncs?: string | undefined;
+};
+
+export const appendWrapperClassRegistration = (
+    context: ModuleContext,
+    registration: WrapperClassRegistration,
+): void => {
+    const { className, gtypeExpr, vfuncs } = registration;
+    if (gtypeExpr === undefined) {
+        return;
+    }
+    context.addRuntimeImport("registerWrapperClass");
+    const args = vfuncs === undefined ? gtypeExpr : `${gtypeExpr}, ${vfuncs}`;
+    context.module.appendRegistration(`registerWrapperClass(${className}, ${args});`);
+};
+
+type InterfaceRegistration = {
+    className: string;
+    makerName: string;
+    gtypeExpr?: string | undefined;
+    vfuncs?: string | undefined;
+};
+
+export const appendInterfaceRegistration = (context: ModuleContext, registration: InterfaceRegistration): void => {
+    const { className, makerName, gtypeExpr, vfuncs } = registration;
+    if (gtypeExpr === undefined) {
+        return;
+    }
+    context.addRuntimeImport("registerInterface");
+    const base = `${className}, ${gtypeExpr}, ${makerName}`;
+    const args = vfuncs === undefined ? base : `${base}, ${vfuncs}`;
+    context.module.appendRegistration(`registerInterface(${args});`);
+};

package/src/store/gi/return-wrap.ts

@@ -0,0 +1,52 @@
+import { renderDescriptor } from "../../analysis/descriptor-render.js";
+import { renderTsType } from "../../analysis/ts-type.js";
+import type { PrimitiveCategory } from "../../gir/primitives.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { ModuleContext } from "../../writer/context.js";
+
+type WrapReturnOptions = {
+    ref: TypeId | undefined;
+    nullable: boolean;
+    valueExpression: string;
+};
+
+export const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): string => {
+    const { ref, nullable, valueExpression } = options;
+    if (ref === undefined) return valueExpression;
+    const type = context.library.typeOf(ref);
+    if (type === undefined) return wrapValue(context, ref, valueExpression);
+    switch (type.kind) {
+        case "primitive":
+            return wrapPrimitive(type.category, nullable, valueExpression);
+        case "varargs":
+            return `(${valueExpression} as unknown[])`;
+        case "callback":
+            return context.library.nameOf(ref) === undefined
+                ? `(${valueExpression} as unknown[])`
+                : `(${valueExpression} as ${renderTsType(context, ref, false)})`;
+        case "enum":
+            return `(${valueExpression} as number)`;
+        case "alias":
+            return type.value.target === undefined
+                ? valueExpression
+                : wrapReturnValue(context, { ref: type.value.target, nullable, valueExpression });
+        default:
+            return wrapValue(context, ref, valueExpression);
+    }
+};
+
+const wrapValue = (context: ModuleContext, ref: TypeId, valueExpression: string): string => {
+    context.addRuntimeImport("fromNative");
+    const descriptor = context.hoistDescriptor(renderDescriptor(context, ref, "none"));
+    return `(fromNative(${descriptor}, ${valueExpression}) as ${renderTsType(context, ref, false)})`;
+};
+
+const wrapPrimitive = (category: PrimitiveCategory, nullable: boolean, valueExpression: string): string => {
+    if (category === "void") return valueExpression;
+    if (category === "string") return `(${valueExpression} as ${nullable ? "string | null" : "string"})`;
+    if (category === "boolean") return `Boolean(${valueExpression})`;
+    if (category === "gtype" || category === "bigint64" || category === "biguint64") {
+        return `(${valueExpression} as bigint)`;
+    }
+    return `(${valueExpression} as number)`;
+};

package/src/store/gi/runtime-override.ts

@@ -0,0 +1,36 @@
+import type { GirFunction } from "../../gir/function.js";
+
+type RuntimeOverride = {
+    generics?: string;
+    signature: string;
+    returnType: string;
+    body: string;
+};
+
+const RUNTIME_OVERRIDES: Map<string, RuntimeOverride> = new Map([
+    [
+        "g_value_get_boxed",
+        {
+            generics: "<T = unknown>",
+            signature: "",
+            returnType: "T",
+            body: 'throw new Error("g_value_get_boxed: runtime override not installed");',
+        },
+    ],
+    [
+        "g_value_set_boxed",
+        {
+            signature: "boxed: object | null",
+            returnType: "void",
+            body: 'throw new Error("g_value_set_boxed: runtime override not installed");',
+        },
+    ],
+]);
+
+export const renderRuntimeOverride = (callable: GirFunction, memberName: string): string | undefined => {
+    if (callable.cIdentifier === undefined) return undefined;
+    const override = RUNTIME_OVERRIDES.get(callable.cIdentifier);
+    if (override === undefined) return undefined;
+    const generics = override.generics ?? "";
+    return `${memberName}${generics}(${override.signature}): ${override.returnType} {\n    ${override.body}\n}`;
+};

package/src/store/gi/signal.ts

@@ -0,0 +1,310 @@
+import { sourceStringLiteral, toCamelCase } from "@gtkx/utils";
+import { tCallback, tObject, tVoid } from "../../analysis/descriptor.js";
+import {
+    isCellInout,
+    omitsPrimaryReturn,
+    renderDescriptor,
+    renderParamDescriptor,
+} from "../../analysis/descriptor-render.js";
+import {
+    collectInterfaceProperties,
+    forEachAncestor,
+    resolveImplementedInterface,
+    resolvePrerequisiteReference,
+} from "../../analysis/inheritance.js";
+import { renderHandlerParameters, renderHandlerResultType } from "../../analysis/param-structure.js";
+import { renderTsType } from "../../analysis/ts-type.js";
+import type { GirClass } from "../../gir/class.js";
+import type { GirParameter, GirSignal } from "../../gir/parameter.js";
+import { isCallerAllocatedOut, isOutParameter } from "../../gir/parameter.js";
+import type { GirProperty } from "../../gir/property.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { indent, renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
+import { parentCompanionRef } from "./companion.js";
+import { isRecordCallerOut, isRecordInout } from "./param-marshal.js";
+
+const SIGNAL_HANDLER_TYPE = "(...args: any[]) => any";
+
+export const renderSignalMembers = (context: ModuleContext, klass: GirClass): string[] => {
+    if (klass.glibGetType === undefined) return [];
+    const signals = collectClassSignals(context, klass);
+    if (signals.length === 0) return [];
+    const isRootObject = context.namespace.name === "GObject" && klass.name === "Object";
+
+    context.addRuntimeImport("connectSignal");
+    context.addRuntimeImport("getSignalBaseName");
+    context.addRuntimeImport("t");
+
+    const connectCases = signals.map((signal) => renderConnectCase(context, signal));
+    const emitCases = signals.map((signal) => renderEmitCase(context, signal));
+    const connectDefault = isRootObject
+        ? `default:\n    throw new globalThis.Error("Unknown signal '" + signal + "'");`
+        : "default:\n    return super.connect(signal, handler, after);";
+    const emitDefault = isRootObject
+        ? `default:\n    throw new globalThis.Error("Unknown signal '" + sigName + "'");`
+        : "default:\n    return super.emit(sigName, ...args);";
+
+    const connectSwitch = `switch (getSignalBaseName(signal)) {\n${indent([...connectCases, connectDefault].join("\n"), 1)}\n}`;
+    const emitSwitch = `switch (getSignalBaseName(sigName)) {\n${indent([...emitCases, emitDefault].join("\n"), 1)}\n}`;
+
+    return [
+        renderBlock(`connect(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, after?: boolean): number`, connectSwitch),
+        renderBlock(`emit(sigName: string, ...args: unknown[]): unknown`, emitSwitch),
+    ];
+};
+
+const SIGNALS_SUFFIX = "Signals";
+const SIGNAL_EMIT_SUFFIX = "SignalEmit";
+
+export const renderSignalDeclarations = (
+    context: ModuleContext,
+    klass: GirClass,
+    className: string,
+    parentlessExtendsObject: boolean,
+): string[] => {
+    const base = { context, klass, className, parentlessExtendsObject };
+    const declarations = [
+        renderSignalMap({ ...base, suffix: SIGNALS_SUFFIX, renderEntry: renderSignalHandlerType }),
+        renderSignalMap({ ...base, suffix: SIGNAL_EMIT_SUFFIX, renderEntry: renderSignalEmitEntry }),
+    ];
+    if (
+        klass.glibGetType !== undefined &&
+        (collectClassSignals(context, klass).length > 0 ||
+            collectNotifyDetails(context, klass).length > 0 ||
+            klass.implements.length > 0)
+    ) {
+        const isRootObject = context.namespace.name === "GObject" && klass.name === "Object";
+        declarations.push(renderSignalConnectInterface(className, isRootObject));
+    }
+    return declarations;
+};
+
+type SignalMapSpec = {
+    context: ModuleContext;
+    klass: GirClass;
+    className: string;
+    parentlessExtendsObject: boolean;
+    suffix: string;
+    renderEntry: (context: ModuleContext, signal: GirSignal) => string;
+};
+
+const renderSignalMap = (spec: SignalMapSpec): string => {
+    const { context, klass, className, parentlessExtendsObject, suffix, renderEntry } = spec;
+    const extendsRefs = signalMapParentRefs(context, klass, parentlessExtendsObject, suffix);
+    const extendsClause = extendsRefs.length === 0 ? "" : ` extends ${extendsRefs.join(", ")}`;
+    const signalEntries = collectClassSignals(context, klass).map((signal) => {
+        const entry = `${sourceStringLiteral(signal.name)}: ${renderEntry(context, signal)};`;
+        return suffix === SIGNALS_SUFFIX ? `${renderJsDoc(signal.doc)}${entry}` : entry;
+    });
+    const entries = [...signalEntries, ...renderNotifyDetailEntries(context, klass, suffix)];
+    return renderBracedOrEmpty(`export interface ${className}${suffix}${extendsClause}`, entries.join("\n"));
+};
+
+const renderNotifyDetailEntries = (context: ModuleContext, klass: GirClass, suffix: string): string[] => {
+    const notifyValue = `${gobjectObjectMapRef(context, suffix)}["notify"]`;
+    return collectNotifyDetails(context, klass).map(
+        (name) => `${sourceStringLiteral(`notify::${name}`)}: ${notifyValue};`,
+    );
+};
+
+const signalMapParentRefs = (
+    context: ModuleContext,
+    klass: GirClass,
+    parentlessExtendsObject: boolean,
+    suffix: string,
+): string[] => {
+    const parentRef = parentCompanionRef(context, klass, suffix);
+    if (parentRef !== undefined) return [parentRef];
+    if (!parentlessExtendsObject) return [];
+    const prerequisiteRefs = klass.prerequisites
+        .map((name) => resolvePrerequisiteReference(context, name))
+        .filter((entry): entry is string => entry !== undefined)
+        .map((entry) => `${entry}${suffix}`);
+    if (prerequisiteRefs.length > 0) return prerequisiteRefs;
+    return [gobjectObjectMapRef(context, suffix)];
+};
+
+const gobjectObjectMapRef = (context: ModuleContext, suffix: string): string => {
+    if (context.namespace.name === "GObject") return `Object${suffix}`;
+    return `${context.addCrossNamespaceImport("GObject")}.Object${suffix}`;
+};
+
+const renderSignalConnectInterface = (className: string, isRootObject: boolean): string => {
+    const map = `${className}${SIGNALS_SUFFIX}`;
+    const emitMap = `${className}${SIGNAL_EMIT_SUFFIX}`;
+    const lines = [
+        `__signals__?: ${map};`,
+        `connect<K extends keyof ${map}>(signal: K, handler: ${map}[K], after?: boolean): number;`,
+        `connect(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, after?: boolean): number;`,
+        `emit<K extends keyof ${emitMap}>(sigName: K, ...args: ${emitMap}[K]["args"]): ${emitMap}[K]["result"];`,
+        "emit(sigName: string, ...args: unknown[]): unknown;",
+    ];
+    if (!isRootObject) {
+        for (const method of ["on", "once", "addEventListener"]) {
+            lines.push(
+                `${method}<K extends keyof ${map}>(signal: K, handler: ${map}[K], after?: boolean): this;`,
+                `${method}(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, after?: boolean): this;`,
+            );
+        }
+        for (const method of ["off", "removeEventListener"]) {
+            lines.push(
+                `${method}<K extends keyof ${map}>(signal: K, handler: ${map}[K]): this;`,
+                `${method}(signal: string, handler: ${SIGNAL_HANDLER_TYPE}): this;`,
+            );
+        }
+    }
+    return renderBracedOrEmpty(`export interface ${className}`, lines.join("\n"));
+};
+
+const renderSignalHandlerType = (context: ModuleContext, signal: GirSignal): string => {
+    const params = renderHandlerParameters(signal.parameters, (ref, nullable) => renderTsType(context, ref, nullable));
+    return `(${params.join(", ")}) => ${renderResultType(context, signal, false, true)}`;
+};
+
+const renderResultType = (
+    context: ModuleContext,
+    signal: GirSignal,
+    includeCallerAllocated: boolean,
+    optOut: boolean,
+): string =>
+    renderHandlerResultType({
+        library: context.library,
+        signal,
+        renderType: (ref, nullable) => renderTsType(context, ref, nullable),
+        includeCallerAllocated,
+        optOut,
+    });
+
+const renderSignalEmitEntry = (context: ModuleContext, signal: GirSignal): string => {
+    const args = renderHandlerParameters(
+        signal.parameters,
+        (ref, nullable) => renderTsType(context, ref, nullable),
+        isCallerAllocatedOut,
+    );
+    const result = renderResultType(context, signal, true, false);
+    return `{ args: [${args.join(", ")}]; result: ${result} }`;
+};
+
+const renderConnectCase = (context: ModuleContext, signal: GirSignal): string => {
+    const callback = renderCallback(context, signal);
+    const body = `return connectSignal(this, signal, { callback: ${callback}, handler, after: after ?? false });`;
+    return renderBlock(`case ${sourceStringLiteral(signal.name)}:`, body);
+};
+
+const renderEmitCase = (context: ModuleContext, signal: GirSignal): string => {
+    const params = signal.parameters.filter((parameter) => !parameter.isVarargs);
+    if (params.some((parameter) => isCallerAllocatedOut(parameter) && !isRecordCallerOut(context, parameter))) {
+        return renderUnsupportedEmitCase(signal);
+    }
+    context.addRuntimeImport("emitSignal");
+
+    let argIndex = 0;
+    const argLiterals = params.map((parameter) => {
+        const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership);
+        if (isOutParameter(parameter)) {
+            return `{ type: ${descriptor}, direction: "out" }`;
+        }
+        if (isCellInout(context.library, parameter)) {
+            return `{ type: ${descriptor}, direction: "inout", value: args[${argIndex++}] }`;
+        }
+        if (isCallerAllocatedOut(parameter)) {
+            return `{ type: ${descriptor}, direction: "out", callerAllocated: true, value: ${renderCallerOutAllocation(context, parameter)} }`;
+        }
+        if (isRecordInout(context, parameter)) {
+            return `{ type: ${descriptor}, direction: "inout", callerAllocated: true, value: args[${argIndex++}] }`;
+        }
+        return `{ type: ${descriptor}, value: args[${argIndex++}] }`;
+    });
+
+    const isVoid = omitsPrimaryReturn(context.library, signal.returnValue);
+    const returnArg = isVoid
+        ? ""
+        : `, ${renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership)}`;
+    const body = `return emitSignal(this, sigName, [${argLiterals.join(", ")}]${returnArg});`;
+
+    return renderBlock(`case ${sourceStringLiteral(signal.name)}:`, body);
+};
+
+const renderUnsupportedEmitCase = (signal: GirSignal): string => {
+    const message = `emit() cannot allocate the caller-allocated out-parameter of '${signal.name}'`;
+    return renderBlock(
+        `case ${sourceStringLiteral(signal.name)}:`,
+        `throw new globalThis.Error(${sourceStringLiteral(message)});`,
+    );
+};
+
+const renderCallerOutAllocation = (context: ModuleContext, parameter: GirParameter): string => {
+    const name = parameter.type === undefined ? undefined : context.library.nameOf(parameter.type);
+    if (name === undefined) {
+        throw new Error("renderCallerOutAllocation: expected a named caller-allocated out-parameter");
+    }
+    return `new ${context.qualify(name.namespaceName, name.typeName)}()`;
+};
+
+const renderCallback = (context: ModuleContext, signal: GirSignal): string => {
+    const params = signal.parameters.filter((parameter) => !parameter.isVarargs);
+    const callbackParamDescriptors = params.map((parameter) =>
+        renderParamDescriptor(context, parameter, parameter.type),
+    );
+    const isVoid = omitsPrimaryReturn(context.library, signal.returnValue);
+    const returnDescriptor = isVoid
+        ? tVoid
+        : renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership);
+    const callbackArgs = [tObject("borrowed"), ...callbackParamDescriptors, tVoid];
+    return tCallback(callbackArgs, returnDescriptor, `{ hasDestroy: true, userDataIndex: ${params.length + 1} }`);
+};
+
+const collectClassSignals = (context: ModuleContext, klass: GirClass): GirSignal[] => {
+    const inheritedNames = collectInheritedSignalNames(context, klass);
+    const seen = new Set<string>();
+    const result: GirSignal[] = [];
+    const consider = (signal: GirSignal): void => {
+        const name = toCamelCase(signal.name);
+        if (inheritedNames.has(name) || seen.has(name)) return;
+        seen.add(name);
+        result.push(signal);
+    };
+    for (const signal of klass.signals) consider(signal);
+    for (const implementName of klass.implements) {
+        const iface = resolveImplementedInterface(context, implementName);
+        if (iface === undefined) continue;
+        for (const signal of iface.klass.signals) consider(signal);
+    }
+    return result;
+};
+
+type NamedMember = { name: string };
+
+const collectInheritedMemberNames = (
+    context: ModuleContext,
+    klass: GirClass,
+    select: (source: GirClass) => NamedMember[],
+): Set<string> => {
+    const names = new Set<string>();
+    forEachAncestor(context, klass, (ancestor, interfaces) => {
+        for (const member of select(ancestor.klass)) names.add(toCamelCase(member.name));
+        for (const iface of interfaces) {
+            for (const member of select(iface.klass)) names.add(toCamelCase(member.name));
+        }
+    });
+    return names;
+};
+
+const collectInheritedSignalNames = (context: ModuleContext, klass: GirClass): Set<string> =>
+    collectInheritedMemberNames(context, klass, (source) => source.signals);
+
+const collectNotifyDetails = (context: ModuleContext, klass: GirClass): string[] => {
+    const inherited = collectInheritedMemberNames(context, klass, (source) => source.properties);
+    const seen = new Set<string>();
+    const result: string[] = [];
+    const consider = (property: GirProperty): void => {
+        const name = toCamelCase(property.name);
+        if (inherited.has(name) || seen.has(name)) return;
+        seen.add(name);
+        result.push(property.name);
+    };
+    for (const property of klass.properties) consider(property);
+    for (const { property } of collectInterfaceProperties(context, klass)) consider(property);
+    return result;
+};