@gtkx/codegen 1.0.0-rc.4 → 1.0.0

package/src/store/gi/interface.ts

@@ -1,20 +1,24 @@
-import { pascalCase } from "@gtkx/utils";
+import { pascalCase, sourceStringLiteral } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
-import type { GirFunction } from "../../gir/function.js";
+import type { GirProperty } from "../../gir/property.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { reservedSignalMemberRename, resolvePrerequisiteReference } from "../../analysis/inheritance.js";
+import { resolveInterfaces } from "../../gir/ancestry.js";
 import { renderJsDoc } from "../../writer/doc.js";
-import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
+import { renderBlock, renderBraced, renderBracedOrEmpty } from "../../writer/emit.js";
 import {
     type Callables,
     dedupeCallables,
     generateBindings,
+    type InstanceMemberRenderer,
     type InstanceScope,
     instanceScope,
+    isEmittableCallable,
     renderClassInstanceMember,
     renderInstanceMethodSignature,
     renderStaticHead,
 } from "./callables.js";
+import { annotationSpec, getDoc } from "./doc-spec.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import {
@@ -24,15 +28,15 @@ import {
 } from "./property-accessor.js";
 import { appendInterfaceRegistration } from "./registration.js";
 import { renderSignalDeclarations, renderSignalMembers } from "./signal.js";
-import { renderVfuncMetadata } from "./vtable.js";
+import {
+    hasCallableVfuncSlots,
+    renderVfuncMembers,
+    renderVfuncMetadata,
+    type VfuncMemberMode,
+} from "./vtable.js";
 
 type InterfaceMemberRenderers = {
-    renderMethod: (
-        context: ModuleContext,
-        callable: GirFunction,
-        scope: InstanceScope,
-        nameOverride?: string,
-    ) => string | undefined;
+    renderMethod: InstanceMemberRenderer;
     renderProperty: (args: PropertyAccessorArgs) => string | undefined;
 };
 
@@ -53,6 +57,20 @@ type PropertyMemberOptions = {
     claimedNames: Set<string>;
 };
 
+type InterfaceClassOptions = {
+    iface: GirClass;
+    className: string;
+    callables: Callables;
+    gtypeExpr: string | undefined;
+    implRef: string;
+};
+
+const BRAND_NOTE = [
+    "Phantom link to the type a class fills to adopt the interface, which `registerClass` reads",
+    "through its `implements` option. It holds no value at runtime. `unknown` asks nothing of the",
+    "class, which is what an interface with no slot to fill carries.",
+].join("\n");
+
 const generateInterface = (context: ModuleContext, iface: GirClass): void => {
     if (!iface.introspectable) {
         return;
@@ -72,8 +90,9 @@ const generateInterface = (context: ModuleContext, iface: GirClass): void => {
 
     generateBindings(context, callables);
     const gtypeExpr = renderSourceGtype(context, iface);
-    context.module.appendDeclaration(renderInterfaceType(context, iface, className, callables));
-    context.module.appendDeclaration(renderInterfaceClass(context, className, callables, gtypeExpr));
+    const implRef = appendInterfaceTypes(context, iface, className, callables) ?? "unknown";
+    const classCode = renderInterfaceClass(context, { iface, className, callables, gtypeExpr, implRef });
+    context.module.appendDeclaration(classCode, context.declaredType(className));
 
     for (const declaration of renderSignalDeclarations(context, iface, className, true)) {
         context.module.appendDeclaration(declaration);
@@ -85,12 +104,116 @@ const generateInterface = (context: ModuleContext, iface: GirClass): void => {
         className,
         makerName: makerName(className),
         gtypeExpr,
-        vfuncs: renderVfuncMetadata(context, iface),
+        layout: renderInterfaceLayout(context, iface, callables),
     });
 };
 
 const makerName = (className: string): string => `make${className}`;
 
+const renderInterfaceLayout = (
+    context: ModuleContext,
+    iface: GirClass,
+    callables: Callables,
+): string | undefined => {
+    const vfuncs = renderVfuncMetadata(context, iface);
+    const properties = renderSlotBackedProperties(context, iface, callables);
+
+    if (vfuncs === undefined && properties === undefined) {
+        return undefined;
+    }
+
+    const entries: string[] = [];
+
+    if (vfuncs !== undefined) {
+        entries.push(`vfuncs: ${vfuncs},`);
+    }
+
+    if (properties !== undefined) {
+        entries.push(`properties: ${properties},`);
+    }
+
+    return renderBraced(entries.join("\n"));
+};
+
+const invokerMembers = (context: ModuleContext, iface: GirClass, callables: Callables): Map<string, string> => {
+    const className = pascalCase(iface.name);
+
+    const invokers: Set<string> = new Set(
+        iface.vfuncs.map((vfunc) => vfunc.invoker).filter((invoker) => invoker !== undefined),
+    );
+
+    const members: Map<string, string> = new Map();
+
+    for (const callable of callables.methods) {
+        if (invokers.has(callable.name) && isEmittableCallable(context, callable)) {
+            members.set(callable.name, reservedSignalMemberRename(className, callable) ?? methodExportName(callable));
+        }
+    }
+
+    return members;
+};
+
+const renderSlotAccessor = (
+    key: string,
+    method: string | undefined,
+    members: Map<string, string>,
+): string | undefined => {
+    const member = method === undefined ? undefined : members.get(method);
+
+    return member === undefined ? undefined : `${key}: ${sourceStringLiteral(member)},`;
+};
+
+const renderSlotBackedProperty = (property: GirProperty, members: Map<string, string>): string | undefined => {
+    if (!property.introspectable) {
+        return undefined;
+    }
+
+    const fields = [
+        renderSlotAccessor("getter", property.getter, members),
+        renderSlotAccessor("setter", property.setter, members),
+    ].filter((field) => field !== undefined);
+
+    if (fields.length === 0) {
+        return undefined;
+    }
+
+    return `${sourceStringLiteral(property.name)}: ${renderBraced(fields.join("\n"))},`;
+};
+
+const renderSlotBackedProperties = (
+    context: ModuleContext,
+    iface: GirClass,
+    callables: Callables,
+): string | undefined => {
+    const members = invokerMembers(context, iface, callables);
+
+    const entries = iface.properties
+        .map((property) => renderSlotBackedProperty(property, members))
+        .filter((entry) => entry !== undefined);
+
+    return entries.length === 0 ? undefined : renderBraced(entries.join("\n"));
+};
+
+const appendInterfaceTypes = (
+    context: ModuleContext,
+    iface: GirClass,
+    className: string,
+    callables: Callables,
+): string | undefined => {
+    const typeCode = renderInterfaceType(context, iface, className, callables);
+    context.module.appendDeclaration(typeCode, context.declaredType(className));
+    const implType = renderInterfaceImplType(context, iface, className);
+
+    if (implType === undefined) {
+        return undefined;
+    }
+
+    const implName = implTypeName(className);
+    context.module.appendDeclaration(implType, context.declaredType(className, implName));
+
+    return implName;
+};
+
 const interfaceTypeExtends = (context: ModuleContext, iface: GirClass): string => {
     const refs = iface.prerequisites
         .map((name) => resolvePrerequisiteReference(context, name))
@@ -111,12 +234,69 @@ const renderInterfaceType = (
 ): string => {
     const members = renderInterfaceTypeMembers(context, iface, callables);
 
-    return `${renderJsDoc(iface.doc)}${renderBracedOrEmpty(
+    return `${getDoc(iface)}${renderBracedOrEmpty(
         `export interface ${className} extends ${interfaceTypeExtends(context, iface)}`,
         members.join("\n"),
     )}`;
 };
 
+const implTypeName = (className: string): string => `${className}Impl`;
+
+const implTypeNote = (className: string): string =>
+    [
+        `Implementer side of \`${className}\`: the vtable slots a class fills to adopt the interface.`,
+        "",
+        `Declare it with \`implements ${implTypeName(className)}\` on a class passed to \`registerClass\``,
+        `with \`${className}\` in \`implements\`. The interface's methods, properties, and signals come from`,
+        "GLib dispatch, so they are not part of this type.",
+        "",
+        "Every slot is optional: an unfilled one keeps whatever the interface installs by default, and a",
+        "GIR update can add one. Declaring a slot pins its signature; declaring it as a class field rather",
+        "than a method satisfies this type but never reaches the vtable.",
+    ].join("\n");
+
+const implPrerequisiteRefs = (context: ModuleContext, iface: GirClass): string[] => {
+    const prerequisites = resolveInterfaces(context.library, context.namespace.name, iface.prerequisites);
+    const refs: string[] = [];
+
+    for (const prerequisite of prerequisites) {
+        if (!hasCallableVfuncSlots(context, prerequisite.namespaceName, prerequisite.klass)) {
+            continue;
+        }
+
+        const name = implTypeName(pascalCase(prerequisite.klass.name));
+        refs.push(context.qualify(prerequisite.namespaceName, name));
+    }
+
+    return refs;
+};
+
+const implTypeExtends = (context: ModuleContext, iface: GirClass): string => {
+    const refs = implPrerequisiteRefs(context, iface);
+
+    return refs.length > 0 ? ` extends ${refs.join(", ")}` : "";
+};
+
+const interfaceVfuncMembers = (context: ModuleContext, iface: GirClass, mode: VfuncMemberMode): string[] =>
+    renderVfuncMembers({ context, klass: iface, mode });
+
+const renderInterfaceImplType = (
+    context: ModuleContext,
+    iface: GirClass,
+    className: string,
+): string | undefined => {
+    const members = interfaceVfuncMembers(context, iface, "requirement");
+
+    if (members.length === 0) {
+        return undefined;
+    }
+
+    return `${renderJsDoc(iface.doc, implTypeNote(className), annotationSpec(iface.annotations))}${renderBracedOrEmpty(
+        `export interface ${implTypeName(className)}${implTypeExtends(context, iface)}`,
+        members.join("\n"),
+    )}`;
+};
+
 const collectMethodMembers = (options: MethodMemberOptions): string[] => {
     const { context, className, scope, callables, renderers, claimedNames } = options;
     const members: string[] = [];
@@ -166,27 +346,34 @@ const renderInterfaceMembers = (
     return [...methodMembers, ...propertyMembers];
 };
 
-const renderInterfaceTypeMembers = (context: ModuleContext, iface: GirClass, callables: Callables): string[] =>
-    renderInterfaceMembers(context, iface, callables, {
+const renderInterfaceTypeMembers = (context: ModuleContext, iface: GirClass, callables: Callables): string[] => [
+    ...renderInterfaceMembers(context, iface, callables, {
         renderMethod: renderInstanceMethodSignature,
         renderProperty: renderPropertyAccessorSignature,
-    });
+    }),
+    ...interfaceVfuncMembers(context, iface, "signature"),
+];
 
-const renderInterfaceClass = (
-    context: ModuleContext,
-    className: string,
-    callables: Callables,
-    gtypeExpr: string | undefined,
-): string => {
+const renderInterfaceClass = (context: ModuleContext, options: InterfaceClassOptions): string => {
+    const { iface, className, callables, gtypeExpr, implRef } = options;
     const members: string[] = [];
 
     if (gtypeExpr !== undefined) {
         members.push(renderInterfaceHasInstance(context, className, gtypeExpr));
     }
 
-    members.push(...renderStaticHead(context, callables, className));
+    members.push(...renderStaticHead(context, callables, className), renderInterfaceBrand(context, implRef));
+
+    return `${getDoc(iface)}${renderBracedOrEmpty(
+        `export abstract class ${className}`,
+        members.join("\n\n"),
+    )}`;
+};
+
+const renderInterfaceBrand = (context: ModuleContext, implRef: string): string => {
+    context.addRuntimeTypeImport("Interface");
 
-    return renderBracedOrEmpty(`export abstract class ${className}`, members.join("\n\n"));
+    return `${renderJsDoc(undefined, BRAND_NOTE)}declare static __impl__: Interface<${implRef}>["__impl__"];`;
 };
 
 const renderInterfaceHasInstance = (context: ModuleContext, className: string, gtypeExpr: string): string => {
@@ -208,7 +395,7 @@ const renderInterfaceMaker = (
     const members = renderInterfaceInstanceMembers(context, iface, callables);
     const classExpression = renderBracedOrEmpty("class extends Base", members.join("\n\n"));
 
-    return `export const ${makerName(className)}: Mixin = (Base) =>\n${classExpression};`;
+    return `${getDoc(iface)}export const ${makerName(className)}: Mixin = (Base) =>\n${classExpression};`;
 };
 
 const renderInterfaceInstanceMembers = (context: ModuleContext, iface: GirClass, callables: Callables): string[] => [
@@ -216,6 +403,7 @@ const renderInterfaceInstanceMembers = (context: ModuleContext, iface: GirClass,
         renderMethod: renderClassInstanceMember,
         renderProperty: renderPropertyAccessor,
     }),
+    ...interfaceVfuncMembers(context, iface, "implementation"),
     ...renderSignalMembers(context, iface),
 ];
 

package/src/store/gi/item-comparators.ts

@@ -5,7 +5,7 @@ import type { ModuleContext } from "../../writer/context.js";
 import { tObject } from "../../analysis/descriptor.js";
 import { inputParameters, parameterIdentifier } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
-import { resolveInterface } from "../../gir/ancestry.js";
+import { resolveInterfaces } from "../../gir/ancestry.js";
 import { callbackAsFunction, type GirCallback } from "../../gir/callback.js";
 
 const COMPARATOR_CALLBACK_TYPES = new Set([
@@ -30,11 +30,9 @@ const isListModelImplementor = (context: ModuleContext, ref: TypeId): boolean =>
         return false;
     }
 
-    return resolved.value.implements.some((interfaceName) => {
-        const iface = resolveInterface(context.library, resolved.namespace.name, interfaceName);
+    const interfaces = resolveInterfaces(context.library, resolved.namespace.name, resolved.value.implements);
 
-        return iface?.namespaceName === "Gio" && iface.klass.name === "ListModel";
-    });
+    return interfaces.some((iface) => iface.namespaceName === "Gio" && iface.klass.name === "ListModel");
 };
 
 const isObjectItemComparator = (context: ModuleContext, fn: GirFunction): boolean => {

package/src/store/gi/method.ts

@@ -14,17 +14,29 @@ import {
     emittedArgIndices,
     foldedLengthIndices,
     foldOutParamShape,
+    type InputParameter,
     inputParameters,
     parameterIdentifier,
 } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { type GirParameter, isCallerAllocatedOut, isInoutParameter, isOutParameter } from "../../gir/parameter.js";
 import { hasUnknownArrayLength, type TypeId } from "../../gir/type-id.js";
+import { areClosuresInvoked } from "./closure-invocation.js";
 import { itemComparatorArgDescriptors, itemComparatorTsType } from "./item-comparators.js";
-import { isCollectibleCallerOut, isHandlePassedInPlace, isHandlePassing } from "./param-marshal.js";
+import { isClosureType, isCollectibleCallerOut, isHandlePassedInPlace, isHandlePassing } from "./param-marshal.js";
 
 type PromisifiedStep = { hasSeenOptional: boolean; expression: string | undefined };
 
+type InputParameterOptions = {
+    shouldSkip: (parameter: GirParameter) => boolean;
+    isOptionalExtra: (parameter: GirParameter) => boolean;
+};
+
+type CallExpressionOptions = {
+    fn: GirFunction;
+    isForcedNullable?: boolean | undefined;
+};
+
 type PromisifyContext = {
     context: ModuleContext;
     asyncFn: GirFunction;
@@ -71,15 +83,34 @@ const arrayLengthArgument = (source: GirParameter, sourceIndex: number): string
 };
 
 const renderMethodSignature = (context: ModuleContext, fn: GirFunction): string =>
-    renderInputParameters(
-        context,
-        fn,
-        () => false,
-        () => false,
-    );
+    renderInputParameters(context, fn, {
+        shouldSkip: () => false,
+        isOptionalExtra: () => false,
+    });
+
+const closureAnnotation = (context: ModuleContext, base: string): string => {
+    context.addRuntimeTypeImport("ClosureCallback");
+
+    return `${base} | ClosureCallback`;
+};
 
-const parameterAnnotation = (context: ModuleContext, fn: GirFunction, parameter: GirParameter): string =>
-    itemComparatorTsType(context, fn, parameter) ?? renderTsType(context, parameter.type, parameter.nullable);
+const requiresClosureMarshal = (context: ModuleContext, fn: GirFunction, ref: TypeId): boolean =>
+    isClosureType(context, ref) && areClosuresInvoked(fn);
+
+const requiresClosureAnnotation = (context: ModuleContext, fn: GirFunction, parameter: GirParameter): boolean =>
+    parameter.type !== undefined && requiresClosureMarshal(context, fn, parameter.type);
+
+const parameterAnnotation = (context: ModuleContext, fn: GirFunction, parameter: GirParameter): string => {
+    const comparator = itemComparatorTsType(context, fn, parameter);
+
+    if (comparator !== undefined) {
+        return comparator;
+    }
+
+    const base = renderTsType(context, parameter.type, parameter.nullable);
+
+    return requiresClosureAnnotation(context, fn, parameter) ? closureAnnotation(context, base) : base;
+};
 
 const isParameterOptional = (parameter: GirParameter, isOptionalExtra: (parameter: GirParameter) => boolean): boolean =>
     parameter.optional || isOptionalExtra(parameter);
@@ -87,27 +118,23 @@ const isParameterOptional = (parameter: GirParameter, isOptionalExtra: (paramete
 const formatParameterPart = (name: string, annotation: string, isOptional: boolean): string =>
     isOptional ? `${name}?: ${annotation}` : `${name}: ${annotation}`;
 
-const renderInputParameters = (
-    context: ModuleContext,
-    fn: GirFunction,
-    shouldSkip: (parameter: GirParameter) => boolean,
-    isOptionalExtra: (parameter: GirParameter) => boolean,
-): string => {
+const renderInputParameters = (context: ModuleContext, fn: GirFunction, options: InputParameterOptions): string => {
     const parts: string[] = [];
     let hasSeenOptional = false;
 
     for (const { parameter, index } of inputParameters(context.library, fn)) {
-        if (shouldSkip(parameter)) {
+        if (options.shouldSkip(parameter)) {
             continue;
         }
 
         const name = parameterIdentifier(parameter, index);
 
-        if (isParameterOptional(parameter, isOptionalExtra)) {
+        if (isParameterOptional(parameter, options.isOptionalExtra)) {
             hasSeenOptional = true;
         }
 
-        parts.push(formatParameterPart(name, parameterAnnotation(context, fn, parameter), hasSeenOptional));
+        const annotation = parameterAnnotation(context, fn, parameter);
+        parts.push(formatParameterPart(name, annotation, hasSeenOptional));
     }
 
     return parts.join(", ");
@@ -118,9 +145,21 @@ const isReturnedOutParameter = (context: ModuleContext, parameter: GirParameter)
     (isCallerAllocatedOut(parameter) && isCollectibleCallerOut(context, parameter)) ||
     isInoutParameter(parameter);
 
-const renderMethodReturnType = (context: ModuleContext, fn: GirFunction): string => {
+const returnedOutParameters = (context: ModuleContext, fn: GirFunction): InputParameter[] => {
     const folded = foldedLengthIndices(context.library, fn);
-    const outs = fn.parameters.filter((p, index) => isReturnedOutParameter(context, p) && !folded.has(index));
+    const result: InputParameter[] = [];
+
+    for (const [index, parameter] of fn.parameters.entries()) {
+        if (isReturnedOutParameter(context, parameter) && !folded.has(index)) {
+            result.push({ parameter, index });
+        }
+    }
+
+    return result;
+};
+
+const renderMethodReturnType = (context: ModuleContext, fn: GirFunction): string => {
+    const outs = returnedOutParameters(context, fn);
 
     const primary = shouldOmitPrimaryReturn(context.library, fn.returnValue)
         ? undefined
@@ -130,7 +169,7 @@ const renderMethodReturnType = (context: ModuleContext, fn: GirFunction): string
         return primary ?? "void";
     }
 
-    const outTypes = outs.map((parameter) => renderTsType(context, parameter.type, parameter.nullable));
+    const outTypes = outs.map(({ parameter }) => renderTsType(context, parameter.type, parameter.nullable));
 
     return foldOutParamShape(primary, outTypes);
 };
@@ -242,7 +281,7 @@ const promisifiedArgument = (
         return arrayLengthArgument(source, sourceIndex);
     }
 
-    return parameterCallExpression(context, parameter, index, hasSeenOptional);
+    return parameterCallExpression(context, parameter, index, { fn: asyncFn, isForcedNullable: hasSeenOptional });
 };
 
 const findCancellableIndex = (context: ModuleContext, parameters: GirParameter[]): number =>
@@ -253,12 +292,10 @@ const renderPromisifiedSignature = (
     asyncFn: GirFunction,
     finishFn: GirFunction,
 ): { signature: string; returnType: string } => {
-    const signature = renderInputParameters(
-        context,
-        asyncFn,
-        (parameter) => isCallbackParameter(context, parameter),
-        (parameter) => isCancellable(context, parameter),
-    );
+    const signature = renderInputParameters(context, asyncFn, {
+        shouldSkip: (parameter) => isCallbackParameter(context, parameter),
+        isOptionalExtra: (parameter) => isCancellable(context, parameter),
+    });
 
     const finishReturn = renderMethodReturnType(context, finishFn);
 
@@ -405,6 +442,7 @@ const planInoutArgument = (
             : undefined;
 
     return planInoutParam(context, parameter, {
+        fn,
         index,
         argIndex: planContext.argIndex,
         isConsumed: folded.has(index),
@@ -433,7 +471,10 @@ const planOutParam = (
     argIndex: ArgIndexOptions,
     isConsumed: boolean,
 ): CallArgPlan => {
-    const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, argIndex);
+    const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, {
+        ...argIndex,
+        hasOutIndirection: true,
+    });
 
     return {
         paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", isConsumed }),
@@ -486,13 +527,14 @@ const planInoutParam = (
     context: ModuleContext,
     parameter: GirParameter,
     options: {
+        fn: GirFunction;
         index: number;
         argIndex: ArgIndexOptions;
         isConsumed: boolean;
         lengthSource?: { source: GirParameter; index: number } | undefined;
     },
 ): CallArgPlan => {
-    const { index, argIndex, isConsumed, lengthSource } = options;
+    const { fn, index, argIndex, isConsumed, lengthSource } = options;
 
     if (isHandlePassedInPlace(context, parameter)) {
         const descriptor = renderDescriptor(context, parameter.type, "none", argIndex);
@@ -507,13 +549,16 @@ const planInoutParam = (
         };
     }
 
-    const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, argIndex);
+    const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, {
+        ...argIndex,
+        hasOutIndirection: true,
+    });
 
     return {
         paramLiteral: paramDescriptorLiteral(descriptor, { direction: "inout", isConsumed }),
         inputExpr:
             lengthSource === undefined
-                ? parameterCallExpression(context, parameter, index)
+                ? parameterCallExpression(context, parameter, index, { fn })
                 : arrayLengthArgument(lengthSource.source, lengthSource.index),
     };
 };
@@ -544,27 +589,30 @@ const planInParam = (
 
     return {
         paramLiteral: paramDescriptorLiteral(descriptor, {}),
-        inputExpr: parameterCallExpression(context, parameter, index),
+        inputExpr: parameterCallExpression(context, parameter, index, { fn }),
     };
 };
 
+const nullableHandleExpression = (name: string): string => `${name} == null ? null : getHandle(${name})`;
+
 const handleArgument = (context: ModuleContext, name: string, isNullable: boolean): string => {
-    if (isNullable) {
-        context.addRuntimeImport("tryGetHandle");
+    context.addRuntimeImport("getHandle");
 
-        return `tryGetHandle(${name})`;
-    }
+    return isNullable ? nullableHandleExpression(name) : `getHandle(${name})`;
+};
 
-    context.addRuntimeImport("getHandle");
+const closureArgument = (context: ModuleContext, name: string, isNullable: boolean): string => {
+    const helper = isNullable ? "tryToClosure" : "toClosure";
+    context.addRuntimeImport(helper);
 
-    return `getHandle(${name})`;
+    return `${helper}(${name})`;
 };
 
 const hashtableArgument = (context: ModuleContext, valueRef: TypeId, name: string): string => {
     if (isHandlePassing(context, valueRef)) {
-        context.addRuntimeImport("tryGetHandle");
+        context.addRuntimeImport("getHandle");
 
-        return `${name} ? globalThis.Array.from(${name}).map(([k, v]) => [k, tryGetHandle(v)]) : null`;
+        return `${name} ? globalThis.Array.from(${name}).map(([k, v]) => [k, ${nullableHandleExpression("v")}]) : null`;
     }
 
     return `${name} ? globalThis.Array.from(${name}) : null`;
@@ -604,8 +652,9 @@ const parameterCallExpression = (
     context: ModuleContext,
     parameter: GirParameter,
     index: number,
-    isForcedNullable = false,
+    options: CallExpressionOptions,
 ): string => {
+    const { fn, isForcedNullable = false } = options;
     const name = parameterIdentifier(parameter, index);
     const ref = parameter.type;
 
@@ -615,6 +664,10 @@ const parameterCallExpression = (
 
     const isNullable = parameter.nullable || parameter.optional || isForcedNullable;
 
+    if (requiresClosureMarshal(context, fn, ref)) {
+        return closureArgument(context, name, isNullable);
+    }
+
     if (isHandlePassing(context, ref)) {
         return handleArgument(context, name, isNullable);
     }
@@ -625,9 +678,12 @@ const parameterCallExpression = (
 };
 
 export {
+    constructibleName,
+    isCallbackParameter,
     methodExportName,
     renderMethodSignature,
     renderMethodReturnType,
+    returnedOutParameters,
     renderPromisifiedBody,
     finishCallExpression,
     renderPromisifiedSignature,

package/src/store/gi/param-marshal.ts

@@ -68,4 +68,18 @@ const isHandlePassing = (context: ModuleContext, ref: TypeId): boolean => {
     }
 };
 
-export { isHandlePassedInPlace, isCollectibleCallerOut, isRecordCallerOut, isRecordInout, isHandlePassing };
+const isClosureType = (context: ModuleContext, ref: TypeId): boolean => {
+    const name = context.library.nameFor(ref);
+
+    return name?.namespaceName === "GObject" && name.typeName === "Closure";
+};
+
+export {
+    isClosureType,
+    isHandlePassedInPlace,
+    isCollectibleCallerOut,
+    isRecordCallerOut,
+    isRecordInout,
+    isHandlePassing,
+    underlyingType,
+};