@gtkx/codegen 1.2.2 → 1.4.0

package/overrides/graphene/structs.ts.ejs

@@ -6,6 +6,7 @@ import { Point as GeneratedPoint, Rect as GeneratedRect, Size as GeneratedSize }
  * @param x the X coordinate
  * @param y the Y coordinate
  * @returns the initialized point
+ * @deprecated Since 1.3. Use `new Point({ x, y })` instead. Removed in v2.
  */
 const createPoint = (x: number, y: number): GeneratedPoint => {
     const point = GeneratedPoint.alloc();
@@ -21,6 +22,7 @@ const createPoint = (x: number, y: number): GeneratedPoint => {
  * @param width the width of the rectangle
  * @param height the height of the rectangle
  * @returns the initialized rectangle
+ * @deprecated Since 1.3. Use `new Rect()` and `init(x, y, width, height)` instead. Removed in v2.
  */
 const createRect = (x: number, y: number, width: number, height: number): GeneratedRect => {
     const rect = GeneratedRect.alloc();
@@ -34,6 +36,7 @@ const createRect = (x: number, y: number, width: number, height: number): Genera
  * @param width the width
  * @param height the height
  * @returns the initialized size
+ * @deprecated Since 1.3. Use `new Size({ width, height })` instead. Removed in v2.
  */
 const createSize = (width: number, height: number): GeneratedSize => {
     const size = GeneratedSize.alloc();
@@ -42,7 +45,17 @@ const createSize = (width: number, height: number): GeneratedSize => {
 };
 
 /** A point with two coordinates. */
-export const Point: typeof GeneratedPoint & { create: typeof createPoint } = Object.assign(GeneratedPoint, {
+export const Point: typeof GeneratedPoint & {
+    /**
+     * Allocates a new `Point` and initializes it to the given coordinates.
+     *
+     * @param x the X coordinate
+     * @param y the Y coordinate
+     * @returns the initialized point
+     * @deprecated Since 1.3. Use `new Point({ x, y })` instead. Removed in v2.
+     */
+    create: typeof createPoint;
+} = Object.assign(GeneratedPoint, {
     create: createPoint,
 });
 
@@ -63,7 +76,19 @@ export type Point = GeneratedPoint;
  * will internally operate on a normalized copy; all functions returning a
  * `graphene_rect_t` will always return a normalized rectangle.
  */
-export const Rect: typeof GeneratedRect & { create: typeof createRect } = Object.assign(GeneratedRect, {
+export const Rect: typeof GeneratedRect & {
+    /**
+     * Allocates a new `Rect` and initializes it to the given origin and size.
+     *
+     * @param x the X coordinate of the origin
+     * @param y the Y coordinate of the origin
+     * @param width the width of the rectangle
+     * @param height the height of the rectangle
+     * @returns the initialized rectangle
+     * @deprecated Since 1.3. Use `new Rect()` and `init(x, y, width, height)` instead. Removed in v2.
+     */
+    create: typeof createRect;
+} = Object.assign(GeneratedRect, {
     create: createRect,
 });
 
@@ -84,7 +109,17 @@ export const Rect: typeof GeneratedRect & { create: typeof createRect } = Object
 export type Rect = GeneratedRect;
 
 /** A size. */
-export const Size: typeof GeneratedSize & { create: typeof createSize } = Object.assign(GeneratedSize, {
+export const Size: typeof GeneratedSize & {
+    /**
+     * Allocates a new `Size` and initializes it to the given width and height.
+     *
+     * @param width the width
+     * @param height the height
+     * @returns the initialized size
+     * @deprecated Since 1.3. Use `new Size({ width, height })` instead. Removed in v2.
+     */
+    create: typeof createSize;
+} = Object.assign(GeneratedSize, {
     create: createSize,
 });
 

package/overrides/gtk/index.ts.ejs

@@ -0,0 +1,2 @@
+export * from "./gtk.js";
+export { WidgetClass } from "./overrides/widget-class.js";

package/overrides/gtk/widget-class.ts.ejs

@@ -0,0 +1,28 @@
+import { type AnyClass, peekTypeClass } from "@gtkx/runtime";
+import { type Type } from "../../gobject/gobject.js";
+import { Widget, WidgetClass as GeneratedWidgetClass } from "../gtk.js";
+
+const peek = (type: Type | AnyClass): GeneratedWidgetClass => peekTypeClass(type, Widget) as GeneratedWidgetClass;
+
+/**
+ * The class structure for the GtkWidget type, with a static `peek` that hands back the class
+ * struct of any widget type so class-level introspection such as `getCssName` works outside a
+ * `classInit` hook.
+ */
+export const WidgetClass: typeof GeneratedWidgetClass & {
+    /**
+     * Returns the class struct of a widget type, referencing the class so it exists even before
+     * the type's first instance. The reference is deliberately never released: once created, a
+     * class struct lives for the rest of the process.
+     *
+     * @param type GType to peek the class struct of, or a registered wrapper class of the type.
+     * @returns the widget type's class struct
+     * @throws when `type` is not a type deriving from `Gtk.Widget`
+     */
+    peek: typeof peek;
+} = Object.assign(GeneratedWidgetClass, { peek });
+
+/**
+ * The class structure for the GtkWidget type.
+ */
+export type WidgetClass = GeneratedWidgetClass;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gtkx/codegen",
-  "version": "1.2.2",
-  "description": "Generates the typed GTKX bindings and API reference from GIR and OpenGL registry data",
+  "version": "1.4.0",
+  "description": "Generates typed GTK bindings and API docs from GIR and GL registries.",
   "keywords": [
     "gtkx",
     "gtk",
@@ -55,11 +55,12 @@
   },
   "dependencies": {
     "@types/node": "^26.2.0",
-    "fast-xml-parser": "^5.10.1",
-    "fast-xml-validator": "^1.4.1",
+    "fast-xml-parser": "^5.11.0",
+    "fast-xml-validator": "^1.4.2",
     "typescript": "^6.0.3",
-    "@gtkx/utils": "1.2.2",
-    "@gtkx/react": "1.2.2"
+    "@gtkx/cairo": "1.4.0",
+    "@gtkx/utils": "1.4.0",
+    "@gtkx/react": "1.4.0"
   },
   "scripts": {
     "release": "tsx ../../scripts/release-package.ts"

package/src/analysis/descriptor-render.ts

@@ -65,6 +65,7 @@ type ArgIndexOptions = {
 };
 
 type CursorArgIndexOptions = ArgIndexOptions & { cursor: GirCursorBounds };
+type CArrayExpressionOptions = ArgIndexOptions & { isCallerAllocated: boolean };
 
 type RenderDescriptorOptions = Partial<ArgIndexOptions> & {
     isCallerAllocated?: boolean;
@@ -77,6 +78,11 @@ type RecordPlacement = {
     isInline?: boolean;
 };
 
+type RecordLayout = {
+    isCallerAllocated: boolean;
+    isInline: boolean;
+};
+
 type FundamentalDescriptor = {
     lib: string;
     refFunc: string;
@@ -84,6 +90,7 @@ type FundamentalDescriptor = {
     typeName: string | undefined;
     ownership: Ownership;
     wrapperClass?: string | undefined;
+    isCallerAllocated?: boolean | undefined;
     isInline?: boolean | undefined;
 };
 
@@ -103,6 +110,7 @@ type FundamentalRecordOptions = {
     unrefFunc: string;
     ownership: Ownership;
     wrapperClass: string | undefined;
+    isCallerAllocated: boolean;
     isInline: boolean;
 };
 
@@ -189,7 +197,7 @@ const renderDescriptor = (
             return tVoid;
         }
         case "callback": {
-            return tUint64;
+            return tBiguint64;
         }
         case "class":
         case "interface":
@@ -199,7 +207,10 @@ const renderDescriptor = (
             return expressionForResolved(context, type, transfer, options);
         }
         case "carray": {
-            return arrayExpression(context, type, transfer, indexOptions);
+            return arrayExpression(context, type, transfer, {
+                ...indexOptions,
+                isCallerAllocated: options.isCallerAllocated === true,
+            });
         }
         case "list": {
             return listExpression(context, type, transfer, indexOptions);
@@ -333,7 +344,11 @@ const findUserDataIndex = (parameters: GirParameter[]): number | undefined => {
     return declared?.closureIndex ?? userDataIndexByName(parameters);
 };
 
-const callbackOptionsArg = (owningParameter: GirParameter, userDataIndex: number | undefined): string[] => {
+const callbackOptionsArg = (
+    owningParameter: GirParameter,
+    userDataIndex: number | undefined,
+    canThrow: boolean,
+): string[] => {
     const options: string[] = [];
 
     if (owningParameter.destroyIndex !== undefined) {
@@ -348,6 +363,10 @@ const callbackOptionsArg = (owningParameter: GirParameter, userDataIndex: number
         options.push(`userDataIndex: ${String(userDataIndex)}`);
     }
 
+    if (canThrow) {
+        options.push("canThrow: true");
+    }
+
     if (owningParameter.scope !== undefined) {
         options.push(`scope: ${sourceStringLiteral(owningParameter.scope)}`);
     }
@@ -376,7 +395,7 @@ const renderCallbackType = (
     return tCallback({
         argTypes,
         returns: renderDescriptor(context, returnValue.type, returnValue.transferOwnership),
-        options: callbackOptionsArg(owningParameter, findUserDataIndex(callback.parameters)),
+        options: callbackOptionsArg(owningParameter, findUserDataIndex(callback.parameters), callback.throws),
     });
 };
 
@@ -401,12 +420,13 @@ const primitiveExpression = (category: PrimitiveCategory, ownership: Ownership):
 };
 
 const renderFundamental = (descriptor: FundamentalDescriptor): string => {
-    const { lib, refFunc, unrefFunc, typeName, ownership, wrapperClass, isInline } = descriptor;
+    const { lib, refFunc, unrefFunc, typeName, ownership, wrapperClass, isCallerAllocated, isInline } = descriptor;
 
     return tFundamental(lib, refFunc, unrefFunc, {
         ownership,
         typeName,
         wrapperClass,
+        isCallerAllocated,
         isInline,
     });
 };
@@ -529,6 +549,11 @@ const renderSelfDescriptor = (context: ModuleContext, instance: GirParameter): s
     return tObject("borrowed");
 };
 
+const recordLayout = (placement: RecordPlacement): RecordLayout => ({
+    isCallerAllocated: placement.isCallerAllocated ?? false,
+    isInline: placement.isInline ?? false,
+});
+
 const recordRefPair = (record: ResolvedRecord): { refFunc: string | undefined; unrefFunc: string | undefined } => ({
     refFunc: record.glibRefFunc ?? record.copyFunc,
     unrefFunc: record.glibUnrefFunc ?? record.freeFunc,
@@ -563,7 +588,7 @@ const structExpression = (
 };
 
 const fundamentalRecordExpression = (options: FundamentalRecordOptions): string => {
-    const { resolved, lib, refFunc, unrefFunc, ownership, wrapperClass, isInline } = options;
+    const { resolved, lib, refFunc, unrefFunc, ownership, wrapperClass, isCallerAllocated, isInline } = options;
 
     return renderFundamental({
         lib,
@@ -572,6 +597,7 @@ const fundamentalRecordExpression = (options: FundamentalRecordOptions): string
         typeName: resolved.value.glibTypeName,
         ownership,
         wrapperClass,
+        isCallerAllocated,
         isInline,
     });
 };
@@ -593,6 +619,7 @@ const boxedRecordExpression = (options: {
         ownership,
         sharedLibrary: resolved.namespace.sharedLibrary,
         getTypeFnName: typeFnName,
+        freeFnName: record.freeFunc,
         isCallerAllocated,
         isInline,
         size: size > 0 ? size : undefined,
@@ -606,11 +633,7 @@ const plainRecordExpression = (
     placement: RecordPlacement,
 ): string => {
     const record = resolved.value;
-
-    const layout = {
-        isCallerAllocated: placement.isCallerAllocated ?? false,
-        isInline: placement.isInline ?? false,
-    };
+    const layout = recordLayout(placement);
 
     if (record.glibGetType === undefined) {
         return structExpression(context, resolved, ownership, layout);
@@ -619,6 +642,17 @@ const plainRecordExpression = (
     return boxedRecordExpression({ context, resolved, ownership, ...layout, typeFnName: record.glibGetType });
 };
 
+const isPlainStruct = (resolved: Extract<EntityType, { kind: "record" }>): boolean => {
+    const record = resolved.value;
+    const { refFunc, unrefFunc } = recordRefPair(record);
+
+    if (refFunc !== undefined && unrefFunc !== undefined && resolved.namespace.sharedLibrary !== undefined) {
+        return false;
+    }
+
+    return record.glibGetType === undefined;
+};
+
 const recordExpression = (
     context: ModuleContext,
     resolved: Extract<EntityType, { kind: "record" }>,
@@ -641,7 +675,7 @@ const recordExpression = (
             unrefFunc,
             ownership,
             wrapperClass,
-            isInline: placement.isInline ?? false,
+            ...recordLayout(placement),
         });
     }
 
@@ -650,16 +684,20 @@ const recordExpression = (
 
 const rawEnumDescriptor = (isSigned: boolean): string => (isSigned ? tInt32 : tUint32);
 
+const flagsMask = (resolved: Extract<EntityType, { kind: "enum" }>): number =>
+    resolved.value.members.reduce((mask, member) => (mask | Number(member.value)) >>> 0, 0);
+
 const enumExpression = (resolved: Extract<EntityType, { kind: "enum" }>): string => {
     const getter = resolved.value.glibGetType;
     const isSigned = resolved.value.members.some((member) => member.value.startsWith("-"));
     const lib = resolved.namespace.sharedLibrary;
+    const isBitfield = resolved.value.kind === "bitfield";
 
     if (getter === undefined || getter === "" || lib === undefined) {
-        return rawEnumDescriptor(isSigned);
+        return isBitfield ? tFlags("", "", isSigned, flagsMask(resolved)) : rawEnumDescriptor(isSigned);
     }
 
-    return resolved.value.kind === "bitfield" ? tFlags(lib, getter, isSigned) : tEnum(lib, getter, isSigned);
+    return isBitfield ? tFlags(lib, getter, isSigned) : tEnum(lib, getter, isSigned);
 };
 
 const expressionForResolved = (
@@ -700,6 +738,7 @@ const elementExpression = (
         ...options,
         cursor: undefined,
         hasOutIndirection: false,
+        isCallerAllocated: false,
     });
 
 const cursorArrayExpression = (
@@ -724,11 +763,14 @@ const arrayLayout = (context: ModuleContext, ref: CArrayType, options: ArgIndexO
         context.library.isByteArrayTyped && !hasUnknownArrayLength(ref) && isByteSequence(context.library, ref),
 });
 
+const fixedArrayLayout = (layout: ArrayLayout, isCallerAllocated: boolean): ArrayLayout =>
+    isCallerAllocated ? { ...layout, isCallerAllocated: true } : layout;
+
 const arrayExpression = (
     context: ModuleContext,
     ref: CArrayType,
     transfer: ParameterTransfer,
-    options: ArgIndexOptions,
+    options: CArrayExpressionOptions,
 ): string => {
     const { cursor } = options;
     const layout = arrayLayout(context, ref, options);
@@ -749,7 +791,7 @@ const arrayExpression = (
     }
 
     if (ref.fixedSize !== undefined) {
-        return tFixedArray(element, ref.fixedSize, ownership, layout);
+        return tFixedArray(element, ref.fixedSize, ownership, fixedArrayLayout(layout, options.isCallerAllocated));
     }
 
     return tArray(element, ownership, layout);
@@ -789,6 +831,8 @@ const aliasExpression = (
 };
 
 export {
+    isPlainStruct,
+    transferOwnership,
     isInlineCallbackRef,
     isSkippedPrimaryReturn,
     isVoidPrimaryReturn,

package/src/analysis/descriptor.ts

@@ -66,6 +66,7 @@ type BoxedOptions = {
     ownership: Ownership;
     sharedLibrary: string | undefined;
     getTypeFnName: string;
+    freeFnName: string | undefined;
     isCallerAllocated: boolean;
     isInline?: boolean;
     size: number | undefined;
@@ -82,6 +83,7 @@ type FundamentalOptions = {
     ownership: Ownership;
     typeName: string | undefined;
     wrapperClass: string | undefined;
+    isCallerAllocated?: boolean | undefined;
     isInline?: boolean | undefined;
 };
 
@@ -90,6 +92,7 @@ type ListDescriptorName = "list" | "slist" | "ptrArray" | "gArray";
 type ArrayLayout = {
     elementSize?: number | undefined;
     isBytes: boolean;
+    isCallerAllocated?: boolean | undefined;
 };
 
 type BindArgs = {
@@ -103,6 +106,7 @@ type FnSpecParts = {
     args: string;
     returns: string;
     isReturnSkipped: boolean;
+    isReturnUnpacked: boolean;
     canThrow: boolean;
 };
 
@@ -113,6 +117,7 @@ type CallbackSpecParts = {
 };
 
 const SKIPPED_RETURN_ENTRY = "isReturnSkipped: true";
+const UNPACKED_RETURN_ENTRY = "isReturnUnpacked: true";
 
 const T: DescriptorNames = {
     bind: "t.bind",
@@ -189,6 +194,7 @@ const tBoxed = (glibName: string, options: BoxedOptions): string =>
                 ? undefined
                 : `sharedLibrary: ${sourceStringLiteral(options.sharedLibrary)}`,
             `getTypeFnName: ${sourceStringLiteral(options.getTypeFnName)}`,
+            options.freeFnName === undefined ? undefined : `freeFnName: ${sourceStringLiteral(options.freeFnName)}`,
             options.isCallerAllocated ? "isCallerAllocated: true" : undefined,
             options.isInline === true ? "isInline: true" : undefined,
             options.size === undefined ? undefined : `size: ${String(options.size)}`,
@@ -218,6 +224,7 @@ const tFundamental = (lib: string, refFunc: string, unrefFunc: string, options:
             `ownership: ${sourceStringLiteral(options.ownership)}`,
             options.typeName === undefined ? undefined : `typeName: ${sourceStringLiteral(options.typeName)}`,
             options.wrapperClass === undefined ? undefined : `wrapperClass: ${options.wrapperClass}`,
+            options.isCallerAllocated === true ? "isCallerAllocated: true" : undefined,
             options.isInline === true ? "isInline: true" : undefined,
         ]),
     ]);
@@ -230,8 +237,13 @@ const tHashTable = (key: string, value: string, ownership: Ownership): string =>
 const tEnum = (lib: string, typeFnName: string, isSigned: boolean): string =>
     call("enum", [sourceStringLiteral(lib), sourceStringLiteral(typeFnName), String(isSigned)]);
 
-const tFlags = (lib: string, typeFnName: string, isSigned: boolean): string =>
-    call("flags", [sourceStringLiteral(lib), sourceStringLiteral(typeFnName), String(isSigned)]);
+const tFlags = (lib: string, typeFnName: string, isSigned: boolean, mask?: number): string =>
+    call("flags", [
+        sourceStringLiteral(lib),
+        sourceStringLiteral(typeFnName),
+        String(isSigned),
+        mask === undefined ? undefined : `0x${mask.toString(16)}`,
+    ]);
 
 const tByteArray = (ownership: Ownership): string => call("byteArray", [sourceStringLiteral(ownership)]);
 
@@ -253,6 +265,7 @@ const arrayLayoutArg = (ownership: Ownership | undefined, layout: ArrayLayout):
     const entries = [
         layout.elementSize === undefined ? undefined : `elementSize: ${String(layout.elementSize)}`,
         layout.isBytes ? "isBytes: true" : undefined,
+        layout.isCallerAllocated === true ? "isCallerAllocated: true" : undefined,
     ].filter((entry): entry is string => entry !== undefined);
 
     return entries.length === 0 ? undefined : `{ ${entries.join(", ")} }`;
@@ -311,12 +324,13 @@ const tBind = (args: BindArgs): string =>
 
 const tFn = (lib: string, cIdentifier: string, spec: FnSpecParts): string => {
     const skipEntry = spec.isReturnSkipped ? `, ${SKIPPED_RETURN_ENTRY}` : "";
+    const unpackEntry = spec.isReturnUnpacked ? `, ${UNPACKED_RETURN_ENTRY}` : "";
     const throwsEntry = spec.canThrow ? ", canThrow: true" : "";
 
     return call("fn", [
         sourceStringLiteral(lib),
         sourceStringLiteral(cIdentifier),
-        `{ args: ${spec.args}, returns: ${spec.returns}${skipEntry}${throwsEntry} }`,
+        `{ args: ${spec.args}, returns: ${spec.returns}${skipEntry}${unpackEntry}${throwsEntry} }`,
     ]);
 };
 

package/src/analysis/param-capability.ts

@@ -1,11 +1,20 @@
-import type { GirCallable, GirParameter } from "../gir/parameter.js";
+import type { GirCallable, GirParameter, ParameterTransfer } from "../gir/parameter.js";
 import type { CArrayType, TypeId } from "../gir/type-id.js";
 import type { GirType } from "../gir/type.js";
 import type { ModuleContext } from "../writer/context.js";
 import { isCallerAllocatedOut, isInoutParameter } from "../gir/parameter.js";
-import { isCollectibleCallerOut, isHandlePassedInPlace, underlyingType } from "../store/gi/param-marshal.js";
+import {
+    isCollectibleCallerOut,
+    isFixedArrayCallerOut,
+    isHandlePassedInPlace,
+    isRecordInout,
+    underlyingType,
+} from "../store/gi/param-marshal.js";
 import { recordInlineSize } from "../store/gi/record-layout.js";
-import { isScalarRef } from "./descriptor-render.js";
+import { isPlainStruct, isScalarRef, transferOwnership } from "./descriptor-render.js";
+import { closureAndDestroyIndices } from "./param-structure.js";
+
+type UnmarshalableSubject = GirCallable & { instance?: GirParameter | undefined };
 
 const POINTER_DEPTH = 1;
 
@@ -119,6 +128,10 @@ const isUnmarshalableCallerOut = (context: ModuleContext, parameter: GirParamete
         return true;
     }
 
+    if (isFixedArrayCallerOut(context, parameter)) {
+        return false;
+    }
+
     return !isCollectibleCallerOut(context, parameter) && !parameter.optional;
 };
 
@@ -143,12 +156,59 @@ const isTypeErasedCallback = (context: ModuleContext, parameter: GirParameter):
     return type?.kind === "callback" && type.value.parameters.length === 0;
 };
 
+const isCallbackParam = (context: ModuleContext, parameter: GirParameter): boolean => {
+    const type = parameter.type === undefined ? undefined : underlyingType(context, parameter.type);
+
+    return type?.kind === "callback";
+};
+
+const hasDetachedClosure = (parameter: GirParameter, index: number): boolean => {
+    const userDataIndex = parameter.closureIndex;
+
+    if (userDataIndex !== undefined && userDataIndex !== index + 1) {
+        return true;
+    }
+
+    const notifyIndex = parameter.destroyIndex;
+
+    return notifyIndex !== undefined && notifyIndex !== index + (userDataIndex === undefined ? 1 : 2);
+};
+
+const hasDetachedCallback = (context: ModuleContext, parameters: GirParameter[]): boolean => {
+    const claimed = closureAndDestroyIndices({ parameters });
+
+    return parameters.some(
+        (parameter, index) =>
+            !claimed.has(index) && isCallbackParam(context, parameter) && hasDetachedClosure(parameter, index),
+    );
+};
+
+const isRefusedTransfer = (
+    context: ModuleContext,
+    ref: TypeId | undefined,
+    transfer: ParameterTransfer,
+): boolean => {
+    if (ref === undefined || transferOwnership(transfer) !== "full") {
+        return false;
+    }
+
+    const type = underlyingType(context, ref);
+
+    return type?.kind === "record" && isPlainStruct(type);
+};
+
+const isLentInPlace = (context: ModuleContext, parameter: GirParameter): boolean =>
+    isCallerAllocatedOut(parameter) || isRecordInout(context, parameter);
+
+const isRefusedParamTransfer = (context: ModuleContext, parameter: GirParameter): boolean =>
+    !isLentInPlace(context, parameter) && isRefusedTransfer(context, parameter.type, parameter.transferOwnership);
+
 const isUnmarshalableCallParam = (context: ModuleContext, parameter: GirParameter): boolean => {
     if (parameter.isVarargs) {
         return false;
     }
 
-    if (isTypeErasedCallback(context, parameter)) {
+    if (isTypeErasedCallback(context, parameter) || isRefusedParamTransfer(context, parameter)) {
         return true;
     }
 
@@ -163,7 +223,10 @@ const isUnmarshalableCallParam = (context: ModuleContext, parameter: GirParamete
     return hasIndirectionMismatch(context, parameter);
 };
 
-const hasUnmarshalableParam = (context: ModuleContext, callable: GirCallable): boolean =>
+const hasUnmarshalableParam = (context: ModuleContext, callable: UnmarshalableSubject): boolean =>
+    (callable.instance !== undefined && isRefusedParamTransfer(context, callable.instance)) ||
+    isRefusedTransfer(context, callable.returnValue.type, callable.returnValue.transferOwnership) ||
+    hasDetachedCallback(context, callable.parameters) ||
     callable.parameters.some((parameter) => isUnmarshalableCallParam(context, parameter));
 
 export { hasUnmarshalableParam };

package/src/analysis/param-structure.ts

@@ -61,7 +61,7 @@ const inputParameters = (library: Library, fn: GirFunction): InputParameter[] =>
     return result;
 };
 
-const closureAndDestroyIndices = (fn: GirFunction): Set<number> => {
+const closureAndDestroyIndices = (fn: Pick<GirCallable, "parameters">): Set<number> => {
     const indices: Set<number> = new Set();
 
     for (const parameter of fn.parameters) {