@gtkx/codegen 1.0.0 → 1.1.0

package/src/analysis/descriptor.ts

@@ -1,4 +1,5 @@
 import { sourceStringLiteral } from "@gtkx/utils";
+import type { GirCursorBounds } from "../gir/parameter.js";
 import { joinArgs } from "../writer/emit.js";
 
 type Ownership = "borrowed" | "full";
@@ -39,6 +40,7 @@ type DescriptorName =
     "byteArray" |
     "sizedArray" |
     "fixedArray" |
+    "cursorArray" |
     "callback" |
     "fn";
 
@@ -92,6 +94,21 @@ type BindArgs = {
     returnType: string;
 };
 
+type FnSpecParts = {
+    args: string;
+    returns: string;
+    isReturnSkipped: boolean;
+    canThrow: boolean;
+};
+
+type CallbackSpecParts = {
+    argTypes: string[];
+    returns: string;
+    options: string[];
+};
+
+const SKIPPED_RETURN_ENTRY = "isReturnSkipped: true";
+
 const T: DescriptorNames = {
     bind: "t.bind",
     int8: "t.int8",
@@ -128,6 +145,7 @@ const T: DescriptorNames = {
     byteArray: "t.byteArray",
     sizedArray: "t.sizedArray",
     fixedArray: "t.fixedArray",
+    cursorArray: "t.cursorArray",
     callback: "t.callback",
     fn: "t.fn",
 };
@@ -235,6 +253,14 @@ const tSizedArray = (
         elementSize === undefined ? undefined : String(elementSize),
     ]);
 
+const tCursorArray = (element: string, bounds: GirCursorBounds, ownership?: Ownership, elementSize?: number): string =>
+    call("cursorArray", [
+        element,
+        `{ baseParamIndex: ${String(bounds.baseIndex)}, sizeParamIndex: ${String(bounds.lengthIndex)} }`,
+        ownership === undefined ? undefined : sourceStringLiteral(ownership),
+        elementSize === undefined ? undefined : String(elementSize),
+    ]);
+
 const tFixedArray = (element: string, length: number, ownership?: Ownership, elementSize?: number): string =>
     call("fixedArray", [
         element,
@@ -243,23 +269,23 @@ const tFixedArray = (element: string, length: number, ownership?: Ownership, ele
         elementSize === undefined ? undefined : String(elementSize),
     ]);
 
-const tCallback = (argTypes: string[], returnType: string, options?: string): string =>
-    call("callback", [`[${argTypes.join(", ")}]`, returnType, options]);
+const tCallback = (spec: CallbackSpecParts): string => {
+    const optionsArg = spec.options.length > 0 ? `{ ${spec.options.join(", ")} }` : undefined;
+
+    return call("callback", [`[${spec.argTypes.join(", ")}]`, spec.returns, optionsArg]);
+};
 
 const tBind = (args: BindArgs): string =>
     call("bind", [args.libExpr, args.symbolExpr, args.argList, args.returnType]);
 
-const tFn = (
-    lib: string,
-    cIdentifier: string,
-    spec: { args: string; returns: string; canThrow: boolean },
-): string => {
+const tFn = (lib: string, cIdentifier: string, spec: FnSpecParts): string => {
+    const skipEntry = spec.isReturnSkipped ? `, ${SKIPPED_RETURN_ENTRY}` : "";
     const throwsEntry = spec.canThrow ? ", canThrow: true" : "";
 
     return call("fn", [
         sourceStringLiteral(lib),
         sourceStringLiteral(cIdentifier),
-        `{ args: ${spec.args}, returns: ${spec.returns}${throwsEntry} }`,
+        `{ args: ${spec.args}, returns: ${spec.returns}${skipEntry}${throwsEntry} }`,
     ]);
 };
 
@@ -288,6 +314,7 @@ export {
     tArray,
     tSizedArray,
     tFixedArray,
+    tCursorArray,
     tCallback,
     tBind,
     tFn,

package/src/analysis/inheritance.ts

@@ -1,14 +1,17 @@
-import { camelCase, lowerFirst, pascalCase, toCamelIdentifier } from "@gtkx/utils";
+import { lowerFirst, pascalCase, sanitizeTypeIdentifier, toCamelIdentifier } from "@gtkx/utils";
 import type { GirClass } from "../gir/class.js";
 import type { GirFunction } from "../gir/function.js";
 import type { Library } from "../gir/library.js";
+import type { GirParameter } from "../gir/parameter.js";
 import type { GirProperty } from "../gir/property.js";
 import type { TypeId } from "../gir/type-id.js";
 import type { ModuleContext } from "../writer/context.js";
 import { ancestorChain, type ResolvedAncestor, resolveInterfaces } from "../gir/ancestry.js";
-import { methodExportName } from "../store/gi/method.js";
-import { resolveAccessorType } from "../store/gi/property-accessor.js";
+import { isEmittableEntity } from "../gir/emittable.js";
+import { memberName, methodExportName } from "../store/gi/method.js";
+import { type InheritedAccessorTypes, resolveAccessorTypes } from "../store/gi/property-accessor.js";
 import { vfuncMemberNames } from "../store/gi/vtable.js";
+import { comparisonContextFor } from "../writer/comparison-context.js";
 import { inputParameters } from "./param-structure.js";
 import { renderTsType } from "./ts-type.js";
 
@@ -18,6 +21,8 @@ type AncestryContext = {
 };
 
 type OwnedProperty = { owner: GirClass; property: GirProperty };
+type DeclaredAccessorType = { type: string; owner: string };
+type DeclaredAccessorTypes = { read: DeclaredAccessorType | undefined; write: DeclaredAccessorType | undefined };
 type MethodSignature = { returnType: string; arity: number };
 
 type InheritedMethod = {
@@ -30,6 +35,11 @@ type InheritedMethods = {
     definitions: Map<string, InheritedMethod>;
 };
 
+type ParameterPair = {
+    own: GirParameter;
+    inherited: GirParameter;
+};
+
 type InheritedMatch = {
     inheritedReturn: string;
     inheritedMethod: InheritedMethod;
@@ -63,7 +73,11 @@ const resolvePrerequisiteReference = (context: ModuleContext, name: string): str
         return undefined;
     }
 
-    return context.qualify(resolved.namespace.name, pascalCase(resolved.value.name));
+    if (!isEmittableEntity(resolved.value)) {
+        return undefined;
+    }
+
+    return context.qualify(resolved.namespace.name, sanitizeTypeIdentifier(resolved.value.name));
 };
 
 const forEachAncestor = (
@@ -99,7 +113,7 @@ const visitInterfaceProperties = (
     }
 };
 
-const forEachInheritedProperty = (
+const forEachAncestorProperty = (
     context: ModuleContext,
     klass: GirClass,
     visit: (owner: GirClass, property: GirProperty) => void,
@@ -113,6 +127,15 @@ const forEachInheritedProperty = (
     });
 };
 
+const forEachInheritedProperty = (
+    context: ModuleContext,
+    klass: GirClass,
+    visit: (owner: GirClass, property: GirProperty) => void,
+): void => {
+    visitInterfaceProperties(resolveDirectInterfaces(context, klass, context.namespace.name), visit);
+    forEachAncestorProperty(context, klass, visit);
+};
+
 const collectSeenPropertyNames = (context: ModuleContext, klass: GirClass): Set<string> => {
     const seen: Set<string> = new Set();
 
@@ -120,7 +143,7 @@ const collectSeenPropertyNames = (context: ModuleContext, klass: GirClass): Set<
         seen.add(toCamelIdentifier(property.name));
     }
 
-    forEachInheritedProperty(context, klass, (_owner, property) => seen.add(toCamelIdentifier(property.name)));
+    forEachAncestorProperty(context, klass, (_owner, property) => seen.add(toCamelIdentifier(property.name)));
 
     return seen;
 };
@@ -159,7 +182,7 @@ const recordAncestorSignatures = (
     signatures: Map<string, MethodSignature>,
 ): void => {
     for (const method of klass.methods) {
-        const name = camelCase(method.name);
+        const name = memberName(method.name);
 
         if (!method.introspectable || signatures.has(name)) {
             continue;
@@ -182,6 +205,9 @@ const ancestorClassMethodSignatures = (context: ModuleContext, klass: GirClass):
     return signatures;
 };
 
+const ancestorClassMethodNames = (context: ModuleContext, klass: GirClass): Set<string> =>
+    new Set(ancestorClassMethodSignatures(context, klass).keys());
+
 const mergeOmissionName = (
     context: ModuleContext,
     method: GirFunction,
@@ -191,7 +217,7 @@ const mergeOmissionName = (
         return undefined;
     }
 
-    const name = camelCase(method.name);
+    const name = memberName(method.name);
     const ancestor = ancestors.get(name);
 
     if (ancestor === undefined) {
@@ -243,24 +269,66 @@ const collectInterfaceMergeOmissions = (
     ...vfuncMergeOmissions(context, klass, iface),
 ];
 
-const collectInheritedPropertyTypes = (context: ModuleContext, klass: GirClass): Map<string, string> => {
-    const types: Map<string, string> = new Map();
+const declaredBy = (type: string | undefined, owner: string): DeclaredAccessorType | undefined =>
+    type === undefined ? undefined : { type, owner };
+
+const reconcileAccessorType = (
+    jsName: string,
+    direction: string,
+    declared: DeclaredAccessorType | undefined,
+    candidate: DeclaredAccessorType | undefined,
+): DeclaredAccessorType | undefined => {
+    if (candidate === undefined) {
+        return declared;
+    }
+
+    if (declared === undefined || declared.type === candidate.type) {
+        return declared ?? candidate;
+    }
 
-    const record = (owner: GirClass, property: GirProperty): void => {
-        const jsName = toCamelIdentifier(property.name);
+    throw new Error(
+        `Cannot type the ${direction} accessor of ${jsName}: ${declared.owner} declares it as ${declared.type} ` +
+        `and ${candidate.owner} declares it as ${candidate.type}. Both are bases of the same class, so no single ` +
+        "member satisfies them; correct the GIR the disagreeing base comes from.",
+    );
+};
 
-        if (types.has(jsName)) {
-            return;
-        }
+const recordInheritedPropertyType = (
+    context: ModuleContext,
+    types: Map<string, DeclaredAccessorTypes>,
+    owner: GirClass,
+    property: GirProperty,
+): void => {
+    const accessorTypes = resolveAccessorTypes(context, property, owner.methods);
 
-        const tsType = resolveAccessorType(context, property, owner.methods);
+    if (accessorTypes === undefined) {
+        return;
+    }
 
-        if (tsType !== undefined) {
-            types.set(jsName, tsType);
-        }
-    };
+    const jsName = toCamelIdentifier(property.name);
+    const declared = types.get(jsName);
 
-    forEachInheritedProperty(context, klass, record);
+    types.set(jsName, {
+        read: reconcileAccessorType(jsName, "read", declared?.read, declaredBy(accessorTypes.readType, owner.name)),
+        write: reconcileAccessorType(jsName, "write", declared?.write, declaredBy(accessorTypes.writeType, owner.name)),
+    });
+};
+
+const collectInheritedPropertyTypes = (
+    context: ModuleContext,
+    klass: GirClass,
+): Map<string, InheritedAccessorTypes> => {
+    const declared: Map<string, DeclaredAccessorTypes> = new Map();
+
+    forEachInheritedProperty(context, klass, (owner, property) => {
+        recordInheritedPropertyType(context, declared, owner, property);
+    });
+
+    const types: Map<string, InheritedAccessorTypes> = new Map();
+
+    for (const [jsName, entry] of declared) {
+        types.set(jsName, { readType: entry.read?.type, writeType: entry.write?.type });
+    }
 
     return types;
 };
@@ -298,7 +366,7 @@ const absorbInheritedMethods = (
             continue;
         }
 
-        const name = camelCase(method.name);
+        const name = memberName(method.name);
 
         if (returnTypes.has(name)) {
             continue;
@@ -332,11 +400,49 @@ const hasMethodConflict = (options: {
     return (
         inheritedReturn !== ownReturn ||
         hasParameterEnumConflict(context, callable, inheritedMethod) ||
-        inputParameters(context.library, callable).length !==
-        inputParameters(context.library, inheritedMethod.method).length
+        hasParameterTypeConflict(context, callable, inheritedMethod.method)
     );
 };
 
+const isCallbackType = (context: ModuleContext, ref: TypeId | undefined): boolean =>
+    ref !== undefined && context.library.typeFor(ref)?.kind === "callback";
+
+const areParametersComparable = (context: ModuleContext, pair: ParameterPair): boolean => {
+    if (isCallbackType(context, pair.own.type) && isCallbackType(context, pair.inherited.type)) {
+        return true;
+    }
+
+    const scratch = comparisonContextFor(context);
+
+    return renderTsType(scratch, pair.own.type, false) === renderTsType(scratch, pair.inherited.type, false);
+};
+
+const inputParameterPairs = (context: ModuleContext, own: GirFunction, inherited: GirFunction): ParameterPair[] => {
+    const ownParams = inputParameters(context.library, own);
+    const inheritedParams = inputParameters(context.library, inherited);
+    const pairs: ParameterPair[] = [];
+
+    for (const [index, entry] of ownParams.entries()) {
+        const other = inheritedParams[index];
+
+        if (other !== undefined) {
+            pairs.push({ own: entry.parameter, inherited: other.parameter });
+        }
+    }
+
+    return pairs;
+};
+
+const hasParameterTypeConflict = (context: ModuleContext, own: GirFunction, inherited: GirFunction): boolean => {
+    const ownCount = inputParameters(context.library, own).length;
+
+    if (ownCount !== inputParameters(context.library, inherited).length) {
+        return true;
+    }
+
+    return inputParameterPairs(context, own, inherited).some((pair) => !areParametersComparable(context, pair));
+};
+
 const conflictRename = (
     context: ModuleContext,
     callable: GirFunction,
@@ -383,26 +489,9 @@ const hasEnumConflict = (
     return ownEnum !== undefined && inheritedEnum !== undefined && ownEnum !== inheritedEnum;
 };
 
-const hasParameterEnumConflict = (context: ModuleContext, own: GirFunction, inherited: InheritedMethod): boolean => {
-    const ownParams = inputParameters(context.library, own);
-    const inheritedParams = inputParameters(context.library, inherited.method);
-    const count = Math.min(ownParams.length, inheritedParams.length);
-
-    for (let index = 0; index < count; index += 1) {
-        const ownParam = ownParams[index];
-        const inheritedParam = inheritedParams[index];
-
-        if (
-            ownParam !== undefined &&
-            inheritedParam !== undefined &&
-            hasEnumConflict(context, ownParam.parameter.type, inheritedParam.parameter.type)
-        ) {
-            return true;
-        }
-    }
-
-    return false;
-};
+const hasParameterEnumConflict = (context: ModuleContext, own: GirFunction, inherited: InheritedMethod): boolean =>
+    inputParameterPairs(context, own, inherited.method).some(
+        (pair) => hasEnumConflict(context, pair.own.type, pair.inherited.type));
 
 const enumIdentity = (context: ModuleContext, ref: TypeId | undefined): string | undefined => {
     if (ref === undefined) {
@@ -419,6 +508,7 @@ const enumIdentity = (context: ModuleContext, ref: TypeId | undefined): string |
 };
 
 export {
+    ancestorClassMethodNames,
     resolvePrerequisiteReference,
     forEachAncestor,
     collectInterfaceProperties,

package/src/analysis/interface-conflicts.ts

@@ -0,0 +1,237 @@
+import type { GirClass } from "../gir/class.js";
+import type { GirFunction } from "../gir/function.js";
+import type { Library } from "../gir/library.js";
+import type { ModuleContext } from "../writer/context.js";
+import { resolveClassOrInterface, type ResolvedAncestor, resolveInterfaces } from "../gir/ancestry.js";
+import { isOutParameter } from "../gir/parameter.js";
+import { memberName } from "../store/gi/method.js";
+import { protectedChainSlotKeys, vfuncCallables, vfuncMemberNames } from "../store/gi/vtable.js";
+import { forEachAncestor } from "./inheritance.js";
+import { inputParameters } from "./param-structure.js";
+import { typeKey } from "./type-key.js";
+
+type MemberTable = Map<string, GirFunction>;
+
+type ClaimedMembers = {
+    inherited: MemberTable;
+    interfaces: MemberTable;
+};
+
+type InterfaceConflictOptions = {
+    context: ModuleContext;
+    klass: GirClass;
+    iface: GirClass;
+    ifaceNamespace: string;
+};
+
+type CallableKeys = {
+    inputs: string[];
+    outputs: string[];
+};
+
+type CallableKeyPair = {
+    own: CallableKeys;
+    other: CallableKeys;
+};
+
+const CHAINABLE_SIGNAL_MEMBERS = ["addEventListener", "off", "on", "once", "removeEventListener"];
+
+const callableKeys = (library: Library, fn: GirFunction): CallableKeys => ({
+    inputs: inputParameters(library, fn).map((entry) => typeKey(library, entry.parameter.type)),
+    outputs: [
+        typeKey(library, fn.returnValue.type),
+        ...fn.parameters
+            .filter((parameter) => isOutParameter(parameter))
+            .map((parameter) => typeKey(library, parameter.type)),
+    ],
+});
+
+const areKeysEqual = (left: string[], right: string[]): boolean =>
+    left.length === right.length && left.every((key, index) => key === right[index]);
+
+const callableKeyPair = (library: Library, own: GirFunction, other: GirFunction): CallableKeyPair => ({
+    own: callableKeys(library, own),
+    other: callableKeys(library, other),
+});
+
+const areCallablesIdentical = (library: Library, own: GirFunction, other: GirFunction): boolean => {
+    const keys = callableKeyPair(library, own, other);
+
+    return areKeysEqual(keys.own.inputs, keys.other.inputs) && areKeysEqual(keys.own.outputs, keys.other.outputs);
+};
+
+const areCallablesAssignable = (library: Library, own: GirFunction, other: GirFunction): boolean => {
+    const keys = callableKeyPair(library, own, other);
+
+    if (keys.own.inputs.length > keys.other.inputs.length) {
+        return false;
+    }
+
+    if (keys.own.inputs.some((key, index) => key !== keys.other.inputs[index])) {
+        return false;
+    }
+
+    return areKeysEqual(keys.other.outputs, ["void"]) || areKeysEqual(keys.own.outputs, keys.other.outputs);
+};
+
+const collectMethods = (klass: GirClass, members: MemberTable): void => {
+    for (const method of klass.methods) {
+        const name = memberName(method.name);
+
+        if (method.introspectable && !members.has(name)) {
+            members.set(name, method);
+        }
+    }
+};
+
+const inheritedMembers = (context: ModuleContext, klass: GirClass): ClaimedMembers => {
+    const inherited: MemberTable = new Map();
+
+    forEachAncestor(context, klass, (ancestor) => {
+        collectMethods(ancestor.klass, inherited);
+    });
+
+    return { inherited, interfaces: new Map() };
+};
+
+const interfaceMembers = (options: InterfaceConflictOptions): MemberTable => {
+    const members: MemberTable = new Map();
+    collectMethods(options.iface, members);
+
+    for (const [key, callable] of vfuncCallables(options.context, options.ifaceNamespace, options.iface)) {
+        members.set(key, callable);
+    }
+
+    return members;
+};
+
+const claimInterfaceMembers = (options: InterfaceConflictOptions, claimed: ClaimedMembers): void => {
+    for (const [key, callable] of interfaceMembers(options)) {
+        if (!claimed.interfaces.has(key)) {
+            claimed.interfaces.set(key, callable);
+        }
+    }
+};
+
+const isConflictingMember = (library: Library, claimed: ClaimedMembers, entry: [string, GirFunction]): boolean => {
+    const [name, method] = entry;
+    const owned = claimed.inherited.get(name);
+
+    if (owned !== undefined) {
+        return !areCallablesAssignable(library, owned, method);
+    }
+
+    const sibling = claimed.interfaces.get(name);
+
+    return sibling !== undefined && !areCallablesIdentical(library, sibling, method);
+};
+
+const conflictingMemberNames = (options: InterfaceConflictOptions, claimed: ClaimedMembers): string[] =>
+    [...interfaceMembers(options)]
+        .filter((entry) => isConflictingMember(options.context.library, claimed, entry))
+        .map(([name]) => name);
+
+const protectedVfuncNames = (options: InterfaceConflictOptions): string[] => {
+    const { context, klass, iface, ifaceNamespace } = options;
+    const protectedKeys = protectedChainSlotKeys(context, klass);
+
+    return vfuncMemberNames(context, ifaceNamespace, iface).filter((key) => protectedKeys.has(key));
+};
+
+const interfaceConflicts = (options: InterfaceConflictOptions, claimed: ClaimedMembers): string[] => {
+    const names = [...conflictingMemberNames(options, claimed), ...protectedVfuncNames(options)];
+
+    return names.length === 0 ? names : [...new Set([...names, ...CHAINABLE_SIGNAL_MEMBERS])];
+};
+
+const rootPrerequisite = (library: Library): ResolvedAncestor[] => {
+    const root = resolveClassOrInterface(library, "GObject", "Object");
+
+    return root === undefined ? [] : [root];
+};
+
+const interfaceSupertypes = (library: Library, entry: ResolvedAncestor): ResolvedAncestor[] => {
+    const prerequisites = entry.klass.prerequisites
+        .map((name) => resolveClassOrInterface(library, entry.namespaceName, name))
+        .filter((prerequisite) => prerequisite !== undefined);
+
+    return prerequisites.length === 0 ? rootPrerequisite(library) : prerequisites;
+};
+
+const classSupertypes = (library: Library, entry: ResolvedAncestor): ResolvedAncestor[] => {
+    const interfaces = resolveInterfaces(library, entry.namespaceName, entry.klass.implements);
+
+    if (entry.klass.parent === undefined) {
+        return interfaces;
+    }
+
+    const parent = resolveClassOrInterface(library, entry.namespaceName, entry.klass.parent);
+
+    return parent === undefined ? interfaces : [parent, ...interfaces];
+};
+
+const directSupertypes = (library: Library, entry: ResolvedAncestor): ResolvedAncestor[] =>
+    entry.klass.isInterface ? interfaceSupertypes(library, entry) : classSupertypes(library, entry);
+
+const collectSupertypeMembers = (
+    library: Library,
+    entry: ResolvedAncestor,
+    visited: Set<string>,
+    members: MemberTable,
+): void => {
+    const key = `${entry.namespaceName}.${entry.klass.name}`;
+
+    if (visited.has(key)) {
+        return;
+    }
+
+    visited.add(key);
+    collectMethods(entry.klass, members);
+
+    for (const supertype of directSupertypes(library, entry)) {
+        collectSupertypeMembers(library, supertype, visited, members);
+    }
+};
+
+const supertypeMembers = (library: Library, base: ResolvedAncestor): MemberTable => {
+    const members: MemberTable = new Map();
+    collectSupertypeMembers(library, base, new Set(), members);
+
+    return members;
+};
+
+const prerequisiteConflicts = (library: Library, iface: GirClass, base: ResolvedAncestor): string[] => {
+    const members: MemberTable = new Map();
+    collectMethods(iface, members);
+    const inherited = supertypeMembers(library, base);
+    const names: string[] = [];
+
+    for (const [name, method] of members) {
+        const owned = inherited.get(name);
+
+        if (owned !== undefined && !areCallablesAssignable(library, method, owned)) {
+            names.push(name);
+        }
+    }
+
+    return names;
+};
+
+const omittedTypeRef = (typeRef: string, omissions: string[]): string => {
+    if (omissions.length === 0) {
+        return typeRef;
+    }
+
+    const keys = [...new Set(omissions)].map((name) => JSON.stringify(name)).join(" | ");
+
+    return `Omit<${typeRef}, ${keys}>`;
+};
+
+export {
+    type ClaimedMembers,
+    claimInterfaceMembers,
+    inheritedMembers,
+    interfaceConflicts,
+    omittedTypeRef,
+    prerequisiteConflicts,
+};

package/src/analysis/param-capability.ts

@@ -3,9 +3,9 @@ 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 { constructibleName } from "../store/gi/method.js";
 import { isCollectibleCallerOut, isHandlePassedInPlace, underlyingType } from "../store/gi/param-marshal.js";
-import { isScalarRef, recordInlineSize } from "./descriptor-render.js";
+import { recordInlineSize } from "../store/gi/record-layout.js";
+import { isScalarRef } from "./descriptor-render.js";
 
 const POINTER_DEPTH = 1;
 
@@ -114,15 +114,12 @@ const hasCallerSuppliedLength = (context: ModuleContext, parameter: GirParameter
     return type?.kind === "carray" && type.lengthParameterIndex !== undefined;
 };
 
-const isUnbuildableCallerOut = (context: ModuleContext, parameter: GirParameter): boolean =>
-    constructibleName(context, parameter.type) === undefined || !isCollectibleCallerOut(context, parameter);
-
 const isUnmarshalableCallerOut = (context: ModuleContext, parameter: GirParameter): boolean => {
     if (hasCallerSuppliedLength(context, parameter)) {
         return true;
     }
 
-    return isUnbuildableCallerOut(context, parameter) && !parameter.optional;
+    return !isCollectibleCallerOut(context, parameter) && !parameter.optional;
 };
 
 const hasIndirectionMismatch = (context: ModuleContext, parameter: GirParameter): boolean => {

package/src/analysis/param-structure.ts

@@ -4,7 +4,7 @@ import type { Library } from "../gir/library.js";
 import type { TypeId } from "../gir/type-id.js";
 import type { JsDocParam } from "../writer/doc-tags.js";
 import { type GirCallable, type GirParameter, isCallerAllocatedOut, isOutParameter } from "../gir/parameter.js";
-import { isCellInout, shouldOmitPrimaryReturn } from "./descriptor-render.js";
+import { isCellInout, isVoidPrimaryReturn } from "./descriptor-render.js";
 
 type InputParameter = {
     parameter: GirParameter;
@@ -277,7 +277,7 @@ const renderHandlerResultType = (options: HandlerResultOptions): string => {
     const { library, signal, renderType, shouldIncludeCallerAllocated, isOptOut } = options;
     const shouldExcludeOut = options.shouldExcludeOut ?? (() => false);
 
-    const primary = shouldOmitPrimaryReturn(library, signal.returnValue)
+    const primary = isVoidPrimaryReturn(library, signal.returnValue)
         ? undefined
         : renderType(signal.returnValue.type, signal.returnValue.nullable);