@gtkx/codegen 1.2.1 → 1.3.0

package/src/store/gi/record-field-accessor.ts

@@ -1,6 +1,7 @@
 import { toCamelIdentifier } from "@gtkx/utils";
 import type { GirAnnotations } from "../../gir/annotations.js";
 import type { GirField } from "../../gir/field.js";
+import type { PrimitiveCategory } from "../../gir/primitives.js";
 import type { GirRecord } from "../../gir/record.js";
 import type { FieldSlot } from "../../gir/size.js";
 import type { TypeId } from "../../gir/type-id.js";
@@ -9,10 +10,16 @@ import type { ModuleContext } from "../../writer/context.js";
 import { isInlineCallbackRef, renderDescriptor } from "../../analysis/descriptor-render.js";
 import { tStruct } from "../../analysis/descriptor.js";
 import { renderTsType } from "../../analysis/ts-type.js";
-import { isUnboundedArray } from "../../analysis/type-shape.js";
+import { isByteSequence, isUnboundedArray } from "../../analysis/type-shape.js";
 import { indent, renderBlock } from "../../writer/emit.js";
 import { getDoc } from "./doc-spec.js";
-import { bitMask, computeRecordFieldSlots, mergeBitfield, type RecordFieldSlot } from "./record-layout.js";
+import {
+    bitMask,
+    computeRecordFieldSlots,
+    inlineArrayStride,
+    mergeBitfield,
+    type RecordFieldSlot,
+} from "./record-layout.js";
 import { wrapReturnValue } from "./return-wrap.js";
 import { isValueMarshalable } from "./value-marshalable.js";
 
@@ -99,6 +106,22 @@ type AccessorOptions = {
     fieldType: TypeId;
 };
 
+type InlineArrayResolution = {
+    element: TypeId;
+    count: number;
+    stride: number;
+    isTypedByteArray: boolean;
+};
+
+type InlineArrayAccessorOptions = {
+    context: ModuleContext;
+    jsName: string;
+    tsType: string;
+    descriptor: string;
+    offset: number;
+    resolution: InlineArrayResolution;
+};
+
 const isMarshalableField = (context: ModuleContext, field: GirField): boolean => {
     if (field.cType?.endsWith("*") === true) {
         return true;
@@ -187,6 +210,9 @@ const isStorableFieldType = (context: ModuleContext, ref: TypeId): boolean => {
     return kind !== "carray" && kind !== "list" && kind !== "hashtable";
 };
 
+const hasArrayAccessor = (context: ModuleContext, target: StructArrayTarget): boolean =>
+    resolveInlineArray(context, target) !== undefined || resolveStructArray(context, target) !== undefined;
+
 const admitAccessibleField = (
     context: ModuleContext,
     slot: RecordFieldSlot,
@@ -201,9 +227,9 @@ const admitAccessibleField = (
 
     const { field, jsName } = admitted;
     const target: StructArrayTarget = { field, jsName, slot: slot.slot, siblingFields };
-    const hasStructArray = resolveStructArray(context, target) !== undefined;
-    const hasAccessor = hasStructArray || isAccessibleFieldType(context, field.type);
-    const isSettable = field.writable && (hasStructArray || isStorableFieldType(context, field.type));
+    const hasArray = hasArrayAccessor(context, target);
+    const hasAccessor = hasArray || isAccessibleFieldType(context, field.type);
+    const isSettable = field.writable && (hasArray || isStorableFieldType(context, field.type));
 
     return hasAccessor ? { ...admitted, isSettable } : undefined;
 };
@@ -222,13 +248,21 @@ const resolveRecordFieldEntry = (
 
     return {
         jsName: admitted.jsName,
-        tsType: renderTsType(context, admitted.field.type, false),
+        tsType: fieldTsType(context, admitted.field.type),
         isWritable: admitted.isSettable,
         doc: admitted.field.doc,
         annotations: admitted.field.annotations,
     };
 };
 
+const fieldTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string => {
+    if (ref !== undefined && context.library.typeFor(ref)?.kind === "callback") {
+        return isNullable ? "bigint | null" : "bigint";
+    }
+
+    return renderTsType(context, ref, isNullable);
+};
+
 const renderRecordFieldAccessor = (
     context: ModuleContext,
     slot: RecordFieldSlot,
@@ -243,17 +277,18 @@ const renderRecordFieldAccessor = (
 
     const { field, jsName } = admitted;
     const doc = getDoc(field);
-    const structArray = renderStructArrayAccessor(context, { field, jsName, slot: slot.slot, siblingFields });
+    const target: StructArrayTarget = { field, jsName, slot: slot.slot, siblingFields };
+    const arrayAccessor = renderInlineArrayAccessor(context, target) ?? renderStructArrayAccessor(context, target);
 
-    if (structArray !== undefined) {
-        return `${doc}${structArray}`;
+    if (arrayAccessor !== undefined) {
+        return `${doc}${arrayAccessor}`;
     }
 
     const descriptor = context.hoistDescriptor(
         renderDescriptor(context, field.type, "none", { isInline: isInlineField(context, field) }),
     );
 
-    const tsType = renderTsType(context, field.type, false);
+    const tsType = fieldTsType(context, field.type);
 
     const accessorOptions: AccessorOptions = {
         context,
@@ -295,7 +330,7 @@ const isAccessorEligibleType = (context: ModuleContext, ref: TypeId): boolean =>
             return context.library.nameFor(ref) !== undefined;
         }
         case "carray": {
-            return type.fixedSize !== undefined;
+            return type.fixedSize !== undefined && type.arrayCType?.endsWith("*") === true;
         }
         case "list":
         case "hashtable":
@@ -338,15 +373,96 @@ const resolveInlineStructFields = (
     return type.value.fields;
 };
 
+const isInlineScalarCategory = (category: PrimitiveCategory, isBehindPointer: boolean): boolean => {
+    if (category === "pointer") {
+        return true;
+    }
+
+    return !isBehindPointer && category !== "void" && category !== "unichar" && category !== "string";
+};
+
+const isInlineArrayElement = (context: ModuleContext, ref: TypeId | undefined, cType: string | undefined): boolean => {
+    const type = ref === undefined ? undefined : context.library.typeFor(ref);
+
+    if (type === undefined) {
+        return false;
+    }
+
+    const isBehindPointer = cType?.endsWith("*") === true;
+
+    switch (type.kind) {
+        case "primitive": {
+            return isInlineScalarCategory(type.category, isBehindPointer);
+        }
+        case "enum": {
+            return !isBehindPointer;
+        }
+        case "record": {
+            return (
+                resolveInlineStructFields(context, ref, cType) !== undefined &&
+                isValueMarshalable(context, type.namespace.name, type.value)
+            );
+        }
+        case "alias": {
+            return isInlineArrayElement(context, type.value.target, cType ?? type.value.targetCType);
+        }
+        case "callback":
+        case "carray":
+        case "class":
+        case "hashtable":
+        case "interface":
+        case "list":
+        case "varargs": {
+            return false;
+        }
+    }
+};
+
+const inlineArrayType = (
+    context: ModuleContext,
+    target: StructArrayTarget,
+): Extract<GirType, { kind: "carray" }> | undefined => {
+    const { field, slot } = target;
+
+    if (field.type === undefined || slot.bitWidth !== undefined) {
+        return undefined;
+    }
+
+    const type = context.library.typeFor(field.type);
+
+    if (type?.kind !== "carray" || type.fixedSize === undefined) {
+        return undefined;
+    }
+
+    return type.arrayCType?.endsWith("*") === true ? undefined : type;
+};
+
+const resolveInlineArray = (context: ModuleContext, target: StructArrayTarget): InlineArrayResolution | undefined => {
+    const type = inlineArrayType(context, target);
+
+    if (type?.fixedSize === undefined || !isInlineArrayElement(context, type.element, type.elementCType)) {
+        return undefined;
+    }
+
+    const stride = inlineArrayStride(context, type);
+
+    if (stride === 0) {
+        return undefined;
+    }
+
+    return {
+        element: type.element,
+        count: type.fixedSize,
+        stride,
+        isTypedByteArray: context.library.isByteArrayTyped && isByteSequence(context.library, type),
+    };
+};
+
 const arrayLengthExpression = (
     arrayRef: Extract<GirType, { kind: "carray" }>,
     siblingFields: GirField[],
 ): string | undefined => {
-    if (arrayRef.fixedSize !== undefined) {
-        return String(arrayRef.fixedSize);
-    }
-
-    if (arrayRef.lengthParameterIndex === undefined) {
+    if (arrayRef.fixedSize !== undefined || arrayRef.lengthParameterIndex === undefined) {
         return undefined;
     }
 
@@ -606,6 +722,82 @@ const resolveStructArray = (context: ModuleContext, target: StructArrayTarget):
     };
 };
 
+const inlineArrayElementOffset = (options: InlineArrayAccessorOptions): string =>
+    `${String(options.offset)} + __index * ${String(options.resolution.stride)}`;
+
+const inlineArrayGetterBlock = (options: InlineArrayAccessorOptions): string => {
+    const { context, jsName, tsType, descriptor, resolution } = options;
+    const container = resolution.isTypedByteArray ? `new ${tsType}(${String(resolution.count)})` : "[]";
+
+    const element = wrapReturnValue(context, {
+        ref: resolution.element,
+        isNullable: false,
+        valueExpression: `read(getHandle(this), ${descriptor}, ${inlineArrayElementOffset(options)})`,
+    });
+
+    const body = [
+        `const __result: ${tsType} = ${container};`,
+        `for (let __index = 0; __index < ${String(resolution.count)}; __index++) {`,
+        indent(`__result[__index] = ${element};`, 1),
+        "}",
+        "return __result;",
+    ].join("\n");
+
+    return renderBlock(`get ${jsName}(): ${tsType}`, body);
+};
+
+const inlineArraySetterBlock = (options: InlineArrayAccessorOptions): string => {
+    const { jsName, tsType, descriptor, resolution } = options;
+
+    const write =
+        `write(getHandle(this), ${descriptor}, ${inlineArrayElementOffset(options)}, ` +
+        `toNative(${descriptor}, __element));`;
+
+    const body = [
+        "for (const [__index, __element] of __value.entries()) {",
+        indent(`if (__index >= ${String(resolution.count)}) {\n    break;\n}\n\n${write}`, 1),
+        "}",
+    ].join("\n");
+
+    return renderBlock(`set ${jsName}(__value: ${tsType})`, body);
+};
+
+const renderInlineArrayAccessor = (context: ModuleContext, target: StructArrayTarget): string | undefined => {
+    const resolution = resolveInlineArray(context, target);
+
+    if (resolution === undefined) {
+        return undefined;
+    }
+
+    const { field, jsName, slot } = target;
+    context.addRuntimeImport("read");
+    context.addRuntimeImport("getHandle");
+    context.addRuntimeImport("t");
+
+    const options: InlineArrayAccessorOptions = {
+        context,
+        jsName,
+        tsType: renderTsType(context, field.type, false),
+        descriptor: context.hoistDescriptor(renderDescriptor(context, resolution.element, "none", { isInline: true })),
+        offset: slot.byteOffset,
+        resolution,
+    };
+
+    const blocks: string[] = [];
+
+    if (field.readable) {
+        blocks.push(inlineArrayGetterBlock(options));
+    }
+
+    if (field.writable) {
+        context.addRuntimeImport("write");
+        context.addRuntimeImport("toNative");
+        blocks.push(inlineArraySetterBlock(options));
+    }
+
+    return blocks.length === 0 ? undefined : blocks.join("\n\n");
+};
+
 const renderStructArrayAccessor = (context: ModuleContext, target: StructArrayTarget): string | undefined => {
     const resolution = resolveStructArray(context, target);
 
@@ -688,6 +880,7 @@ const setterBlock = (options: AccessorOptions): string =>
     );
 
 export {
+    fieldTsType,
     isEmittableField,
     isInlineField,
     isStorableFieldType,

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

@@ -56,6 +56,9 @@ const recordInlineSize = (context: ModuleContext, record: ResolvedRecordValue):
     return size > 0 ? size : undefined;
 };
 
+const inlineArrayStride = (context: ModuleContext, array: Extract<GirType, { kind: "carray" }>): number =>
+    layoutOfType(context, array.element, array.elementCType, new Set()).size;
+
 const bitMask = (width: number): number => {
     if (width >= 32) {
         return 0xFF_FF_FF_FF;
@@ -224,4 +227,11 @@ const resolveAliasLayout = (
     return layoutOfType(context, ref, resolved.value.targetCType, visited);
 };
 
-export { computeRecordFieldSlots, recordInlineSize, bitMask, mergeBitfield, type RecordFieldSlot };
+export {
+    computeRecordFieldSlots,
+    inlineArrayStride,
+    recordInlineSize,
+    bitMask,
+    mergeBitfield,
+    type RecordFieldSlot,
+};

package/src/store/gi/record.ts

@@ -12,14 +12,6 @@ import { computeRecordFieldSlots } from "./record-layout.js";
 import { appendWrapperClassRegistration } from "./registration.js";
 import { isConstructibleRecord } from "./value-marshalable.js";
 
-type RecordMembersOptions = {
-    context: ModuleContext;
-    record: GirRecord;
-    className: string;
-    callables: Callables;
-    gtypeExpr: string | undefined;
-};
-
 const isGErrorRecord = (context: ModuleContext, record: GirRecord): boolean =>
     context.namespace.name === "GLib" && record.glibGetType === "g_error_get_type";
 
@@ -38,8 +30,7 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
     };
 
     generateBindings(context, callables);
-    const gtypeExpr = renderSourceGtype(context, record);
-    const members = renderRecordMembers({ context, record, className, callables, gtypeExpr });
+    const members = renderRecordMembers(context, record, className, callables);
     const body = indentMembers(members);
     const heritage = isErrorSubclass ? " extends globalThis.Error" : "";
     const doc = getDoc(record);
@@ -59,16 +50,29 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
         });
     }
 
+    const gtypeExpr = renderSourceGtype(context, record);
+
     appendWrapperClassRegistration(context, {
         className,
         gtypeExpr,
     });
 };
 
-const renderRecordMembers = (options: RecordMembersOptions): string[] => {
-    const { context, record, className, callables, gtypeExpr } = options;
+const renderRecordMembers = (
+    context: ModuleContext,
+    record: GirRecord,
+    className: string,
+    callables: Callables,
+): string[] => {
     const isErrorSubclass = isGErrorRecord(context, record);
-    const { members, claimedNames } = renderPlainTypeMembers({ context, className, callables, gtypeExpr });
+
+    const { members, claimedNames } = renderPlainTypeMembers({
+        context,
+        className,
+        callables,
+        hasGtype: record.glibGetType !== undefined,
+    });
+
     members.unshift(renderRecordConstructor(context, { record, className, callables, isErrorSubclass }));
     const { slots } = computeRecordFieldSlots(context, record.fields, record.isUnion);
 

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

@@ -21,7 +21,7 @@ const RUNTIME_OVERRIDES: Map<string, RuntimeOverride> = new Map([
     [
         "g_value_set_boxed",
         {
-            signature: "boxed: object | null",
+            signature: "boxed: object | string | number | bigint | boolean | null",
             returnType: "void",
             body: 'throw new Error("g_value_set_boxed: runtime override not installed");',
             renames: [["v_boxed", "boxed"]],

package/src/store/gi/signal.ts

@@ -17,7 +17,7 @@ import {
     resolvePrerequisiteReference,
 } from "../../analysis/inheritance.js";
 import { renderHandlerParameters, renderHandlerResultType } from "../../analysis/param-structure.js";
-import { renderTsType } from "../../analysis/ts-type.js";
+import { renderParameterTsType, renderTsType } from "../../analysis/ts-type.js";
 import { resolveInterfaces } from "../../gir/ancestry.js";
 import { isCallerAllocatedOut, isOutParameter } from "../../gir/parameter.js";
 import { renderJsDoc } from "../../writer/doc.js";
@@ -259,7 +259,7 @@ const renderResultType = (
 const renderSignalEmitEntry = (context: ModuleContext, signal: GirCallable): string => {
     const args = renderHandlerParameters(
         signal.parameters,
-        (ref, nullable) => renderTsType(context, ref, nullable),
+        (ref, nullable) => renderParameterTsType(context, ref, nullable),
         isCallerAllocatedOut,
     );
 

package/src/store/gi/vtable.ts

@@ -11,6 +11,7 @@ import type { JsDocSpec } from "../../writer/doc.js";
 import {
     isInlineCallbackRef,
     isScalarRef,
+    renderCallbackType,
     renderDescriptor,
     renderParamDescriptor,
 } from "../../analysis/descriptor-render.js";
@@ -19,7 +20,6 @@ import {
     handlerParameters,
     parameterIdentifier,
     renamesWithInstance,
-    renderHandlerParameters,
     renderHandlerResultType,
 } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
@@ -74,6 +74,12 @@ type Vtable = {
     slots: VtableSlot[];
 };
 
+type SlotParamPlan = {
+    parameters: GirParameter[];
+    argIndexMap: Map<number, number>;
+    decoded: Set<GirParameter>;
+};
+
 const PADDING_FIELD_NAME = /^(?:reserved|padding)\d*$/i;
 
 const UNCALLABLE_SLOT_KEYS: Set<string> = new Set([
@@ -86,6 +92,7 @@ const UNCALLABLE_SLOT_KEYS: Set<string> = new Set([
 const VTABLE_CACHE: WeakMap<GirClass, Vtable> = new WeakMap();
 const PROTECTED_SLOT_NOTE = "It is `protected`, so only a subclass chaining up reaches it.";
 const PUBLIC_SLOT_NOTE = "Calling it from anywhere else re-enters the slot on a live instance.";
+const OPAQUE_CALLBACK_NOTE = "Received as the raw address of the C function pointer.";
 
 const vfuncMemberName = (fieldName: string): string => `vfunc${pascalCase(fieldName)}`;
 
@@ -125,6 +132,79 @@ const vtableCallbackType = (context: ModuleContext, field: GirField): GirCallbac
     return type.value;
 };
 
+const isCallbackParam = (context: ModuleContext, parameter: GirParameter): boolean =>
+    parameter.type !== undefined && context.library.typeFor(parameter.type)?.kind === "callback";
+
+const isDecodedCallbackParam = (context: ModuleContext, parameter: GirParameter, index: number): boolean =>
+    isCallbackParam(context, parameter) &&
+    parameter.closureIndex === index + 1 &&
+    parameter.destroyIndex === undefined;
+
+const decodedSlotParams = (context: ModuleContext, callback: GirCallback): Set<GirParameter> => {
+    const decoded: Set<GirParameter> = new Set();
+
+    for (const [index, parameter] of callback.parameters.entries()) {
+        if (isDecodedCallbackParam(context, parameter, index)) {
+            decoded.add(parameter);
+        }
+    }
+
+    return decoded;
+};
+
+const companionIndices = (decoded: Set<GirParameter>): Set<number> => {
+    const companions: Set<number> = new Set();
+
+    for (const parameter of decoded) {
+        if (parameter.closureIndex !== undefined) {
+            companions.add(parameter.closureIndex);
+        }
+    }
+
+    return companions;
+};
+
+const slotParamPlan = (context: ModuleContext, callback: GirCallback): SlotParamPlan => {
+    const decoded = decodedSlotParams(context, callback);
+    const companions = companionIndices(decoded);
+    const parameters: GirParameter[] = [];
+    const argIndexMap: Map<number, number> = new Map();
+
+    for (const [index, parameter] of callback.parameters.entries()) {
+        if (companions.has(index)) {
+            continue;
+        }
+
+        argIndexMap.set(index, parameters.length);
+        parameters.push(parameter);
+    }
+
+    return { parameters, argIndexMap, decoded };
+};
+
+const isOpaqueCallbackParam = (context: ModuleContext, plan: SlotParamPlan, parameter: GirParameter): boolean =>
+    isCallbackParam(context, parameter) && !plan.decoded.has(parameter);
+
+const renderSlotParamDescriptor = (context: ModuleContext, parameter: GirParameter, plan: SlotParamPlan): string => {
+    if (plan.decoded.has(parameter)) {
+        const callbackDescriptor = renderCallbackType(context, parameter.type, parameter);
+
+        if (callbackDescriptor !== undefined) {
+            return callbackDescriptor;
+        }
+    }
+
+    return renderParamDescriptor(context, parameter, parameter.type, { argIndexMap: plan.argIndexMap });
+};
+
+const renderSlotParamTsType = (context: ModuleContext, plan: SlotParamPlan, parameter: GirParameter): string => {
+    if (isOpaqueCallbackParam(context, plan, parameter)) {
+        return parameter.nullable ? "bigint | null" : "bigint";
+    }
+
+    return renderTsType(context, parameter.type, parameter.nullable);
+};
+
 const vtableSlotEntry = (
     context: ModuleContext,
     field: GirField,
@@ -387,15 +467,35 @@ const hasCallableVfuncSlots = (context: ModuleContext, namespaceName: string, kl
 
 const slotDoc = (slot: VtableSlot): string | undefined => slot.vfunc?.doc ?? slot.field.doc ?? slot.callback.doc;
 
-const slotDocParameters = (slot: VtableSlot): GirParameter[] => {
+const slotParamDoc = (
+    context: ModuleContext,
+    plan: SlotParamPlan,
+    parameter: GirParameter,
+    doc: string | undefined,
+): string | undefined => {
+    if (!isOpaqueCallbackParam(context, plan, parameter)) {
+        return doc;
+    }
+
+    return doc === undefined ? OPAQUE_CALLBACK_NOTE : `${doc} ${OPAQUE_CALLBACK_NOTE}`;
+};
+
+const slotDocParameters = (context: ModuleContext, slot: VtableSlot): GirParameter[] => {
+    const plan = slotParamPlan(context, slot.callback);
     const [, ...parameters] = slot.callback.parameters;
     const vfuncParameters = slot.vfunc?.parameters ?? [];
 
-    return parameters.map((parameter, index) => ({ ...parameter, doc: vfuncParameters[index]?.doc ?? parameter.doc }));
+    return parameters
+        .map((parameter, index) => ({ parameter, index }))
+        .filter(({ index }) => plan.argIndexMap.has(index + 1))
+        .map(({ parameter, index }) => ({
+            ...parameter,
+            doc: slotParamDoc(context, plan, parameter, vfuncParameters[index]?.doc ?? parameter.doc),
+        }));
 };
 
-const slotDocSpec = (slot: VtableSlot): JsDocSpec => {
-    const parameters = slotDocParameters(slot);
+const slotDocSpec = (context: ModuleContext, slot: VtableSlot): JsDocSpec => {
+    const parameters = slotDocParameters(context, slot);
     const source = slot.vfunc ?? slot.callback;
 
     return {
@@ -446,12 +546,18 @@ const isCallableSlot = (context: ModuleContext, slot: VtableSlot): boolean =>
     !UNCALLABLE_SLOT_KEYS.has(slot.key) && !hasUnannotatedPointerParam(context, slot);
 
 const vfuncSlotSignature = (context: ModuleContext, slot: VtableSlot, isOptional = false): VfuncSignature => {
-    const [, ...parameters] = slot.callback.parameters;
+    const plan = slotParamPlan(context, slot.callback);
+    const [, ...parameters] = plan.parameters;
 
     const renderType = (ref: TypeId | undefined, isNullable: boolean): string =>
         renderTsType(context, ref, isNullable);
 
-    const signature = renderHandlerParameters(parameters, renderType).join(", ");
+    const signature = handlerParameters(parameters)
+        .map(
+            (parameter, index) =>
+                `${parameterIdentifier(parameter, index)}: ${renderSlotParamTsType(context, plan, parameter)}`)
+        .join(", ");
+
     const folded = foldedLengthParameters(context.library, slot.callback);
 
     const returnType = renderHandlerResultType({
@@ -470,13 +576,13 @@ const renderVfuncMember = (options: VfuncMemberOptions): string => {
     const { context, ownerRef, slot, mode, isProtected } = options;
     const { header, returnType } = vfuncSlotSignature(context, slot, mode === "requirement");
     const declaration = `${isProtected ? "protected " : ""}${header}`;
-    const doc = renderJsDoc(slotDoc(slot), vfuncMemberNote(options), slotDocSpec(slot));
+    const doc = renderJsDoc(slotDoc(slot), vfuncMemberNote(options), slotDocSpec(context, slot));
 
     if (mode !== "implementation") {
         return `${doc}${declaration};`;
     }
 
-    const [, ...parameters] = slot.callback.parameters;
+    const [, ...parameters] = slotParamPlan(context, slot.callback).parameters;
 
     const inputs = handlerParameters(parameters).map((parameter, index) =>
         parameterIdentifier(parameter, index));
@@ -511,9 +617,10 @@ const isVtableSlotEligible = (context: ModuleContext, callback: GirCallback): bo
 
 const renderVtableSlotDescriptor = (context: ModuleContext, vtable: Vtable, slot: VtableSlot): string => {
     const { key, field, callback, byteOffset } = slot;
+    const plan = slotParamPlan(context, callback);
 
-    const argDescriptors = callback.parameters
-        .map((param) => renderParamDescriptor(context, param, param.type))
+    const argDescriptors = plan.parameters
+        .map((param) => renderSlotParamDescriptor(context, param, plan))
         .join(", ");
 
     const returnDescriptor = renderDescriptor(