@gtkx/codegen 1.0.0-rc.2 → 1.0.0-rc.4

package/src/store/gi/callables.ts

@@ -5,7 +5,6 @@ import { hasCallerAllocatedArrayLength } from "../../analysis/param-structure.js
 import { renderJsDoc } from "../../writer/doc.js";
 import { renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
-import { hasClassStructReference } from "./class-struct-record.js";
 import { renderFnExpression } from "./function.js";
 import { gtypeMemberDeclaration } from "./gtype-binding.js";
 import {
@@ -35,7 +34,7 @@ type CallableMemberOptions = {
     resolveName: (callable: GirFunction) => string | undefined;
     isStatic: boolean;
     returnTypeOverride?: string | undefined;
-    allowRuntimeOverride?: boolean;
+    canUseRuntimeOverride?: boolean;
 };
 
 type StaticEntryOptions = {
@@ -111,10 +110,6 @@ const renderBinding = (
         return undefined;
     }
 
-    if (hasClassStructReference(context, callable)) {
-        return undefined;
-    }
-
     const expression = renderFnExpression(context, callable);
 
     if (expression === undefined) {
@@ -164,9 +159,9 @@ const runtimeOverrideMember = (
     callable: GirFunction,
     name: string,
     doc: string,
-    allow: boolean | undefined,
+    canUseRuntimeOverride: boolean | undefined,
 ): string | undefined => {
-    if (allow !== true) {
+    if (canUseRuntimeOverride !== true) {
         return undefined;
     }
 
@@ -188,7 +183,7 @@ const renderCallableMember = (
 
     const { cIdentifier, name } = resolved;
     const doc = renderJsDoc(callable.doc);
-    const override = runtimeOverrideMember(callable, name, doc, options.allowRuntimeOverride);
+    const override = runtimeOverrideMember(callable, name, doc, options.canUseRuntimeOverride);
 
     if (override !== undefined) {
         return override;
@@ -245,7 +240,7 @@ const renderInstanceMethod = (
     renderCallableMember(context, callable, {
         resolveName: (member) => nameOverride ?? methodExportName(member),
         isStatic: false,
-        allowRuntimeOverride: true,
+        canUseRuntimeOverride: true,
     });
 
 const resolveInstanceMember = (
@@ -371,7 +366,6 @@ const isEmittableCallable = (context: ModuleContext, callable: GirFunction): boo
     callable.introspectable &&
     callable.shadowedBy === undefined &&
     callable.cIdentifier !== undefined &&
-    !hasClassStructReference(context, callable) &&
     !hasCallerAllocatedArrayLength(context.library, callable);
 
 const constructorMemberName = (girName: string): string | undefined => {

package/src/store/gi/constant.ts

@@ -6,8 +6,6 @@ import type { ModuleContext } from "../../writer/context.js";
 import { renderJsDoc } from "../../writer/doc.js";
 
 const TRUE_VALUES: Set<string> = new Set(["true", "1"]);
-// A `gint64`/`guint64` constant is typed `bigint`, and its decimal text does not survive a double:
-// G_MAXINT64 rounds to 2^63. The literal has to carry the BigInt suffix the type promises.
 const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["bigint64", "biguint64", "gtype"]);
 
 const generateConstant = (context: ModuleContext, constant: GirConstant): void => {

package/src/store/gi/function.ts

@@ -7,7 +7,6 @@ import { hasCallerAllocatedArrayLength } from "../../analysis/param-structure.js
 import { renderJsDoc } from "../../writer/doc.js";
 import { arrayLiteral, renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
-import { hasClassStructReference } from "./class-struct-record.js";
 import {
     planCallArgs,
     renderMethodBody,
@@ -33,13 +32,9 @@ const renderFnExpression = (context: ModuleContext, fn: GirFunction): string | u
     const params = planCallArgs(context, fn).map((arg) => arg.paramLiteral);
     const ret = renderReturnDescriptor(context, fn);
 
-    return tFn(library, fn.cIdentifier, { args: arrayLiteral(params), returns: ret, throws: fn.throws });
+    return tFn(library, fn.cIdentifier, { args: arrayLiteral(params), returns: ret, canThrow: fn.throws });
 };
 
-// `moved-to` names the type member this function is also reachable as, so the namespace-level copy
-// is a second export of one binding. Suppressing it is only right when that member is really
-// emitted: 15 of Gtk-4.0's 28 `moved-to` targets are enum or error-domain members codegen emits no
-// static for, and dropping those would delete API with nothing to replace it.
 const isMovedOntoEmittedMember = (context: ModuleContext, fn: GirFunction): boolean => {
     const [typeName, memberName] = fn.movedTo?.split(".") ?? [];
 
@@ -63,7 +58,6 @@ const canEmitNamespaceFunction = (context: ModuleContext, fn: GirFunction): bool
     !isMovedOntoEmittedMember(context, fn) &&
     fn.shadowedBy === undefined &&
     fn.cIdentifier !== undefined &&
-    !hasClassStructReference(context, fn) &&
     !hasCallerAllocatedArrayLength(context.library, fn);
 
 const generateNamespaceFunction = (context: ModuleContext, fn: GirFunction): void => {

package/src/store/gi/method.ts

@@ -23,7 +23,7 @@ import { hasUnknownArrayLength, type TypeId } from "../../gir/type-id.js";
 import { itemComparatorArgDescriptors, itemComparatorTsType } from "./item-comparators.js";
 import { isCollectibleCallerOut, isHandlePassedInPlace, isHandlePassing } from "./param-marshal.js";
 
-type PromisifiedStep = { sawOptional: boolean; expression: string | undefined };
+type PromisifiedStep = { hasSeenOptional: boolean; expression: string | undefined };
 
 type PromisifyContext = {
     context: ModuleContext;
@@ -44,8 +44,8 @@ type CallArgPlan = {
 
 type ParamDescriptorOptions = {
     direction?: "out" | "inout";
-    callerAllocated?: boolean;
-    consumed?: boolean;
+    isCallerAllocated?: boolean;
+    isConsumed?: boolean;
 };
 
 type ArgIndexOptions = {
@@ -94,7 +94,7 @@ const renderInputParameters = (
     isOptionalExtra: (parameter: GirParameter) => boolean,
 ): string => {
     const parts: string[] = [];
-    let isSawOptional = false;
+    let hasSeenOptional = false;
 
     for (const { parameter, index } of inputParameters(context.library, fn)) {
         if (shouldSkip(parameter)) {
@@ -104,10 +104,10 @@ const renderInputParameters = (
         const name = parameterIdentifier(parameter, index);
 
         if (isParameterOptional(parameter, isOptionalExtra)) {
-            isSawOptional = true;
+            hasSeenOptional = true;
         }
 
-        parts.push(formatParameterPart(name, parameterAnnotation(context, fn, parameter), isSawOptional));
+        parts.push(formatParameterPart(name, parameterAnnotation(context, fn, parameter), hasSeenOptional));
     }
 
     return parts.join(", ");
@@ -139,36 +139,36 @@ const classifyPromisifiedParameter = (
     promisify: PromisifyContext,
     parameter: GirParameter,
     index: number,
-    state: { cancellableIndex: number; sawOptional: boolean },
+    state: { cancellableIndex: number; hasSeenOptional: boolean },
 ): PromisifiedStep => {
     if (parameter.isVarargs) {
-        return { sawOptional: state.sawOptional, expression: undefined };
+        return { hasSeenOptional: state.hasSeenOptional, expression: undefined };
     }
 
     if (index === state.cancellableIndex) {
-        return { sawOptional: true, expression: undefined };
+        return { hasSeenOptional: true, expression: undefined };
     }
 
     if (shouldSkipPromisifiedParameter(promisify, parameter, index)) {
-        return { sawOptional: state.sawOptional, expression: undefined };
+        return { hasSeenOptional: state.hasSeenOptional, expression: undefined };
     }
 
-    const isSawOptional = state.sawOptional || parameter.optional;
+    const hasSeenOptional = state.hasSeenOptional || parameter.optional;
 
-    return { sawOptional: isSawOptional, expression: promisifiedArgument(promisify, parameter, index, isSawOptional) };
+    return { hasSeenOptional, expression: promisifiedArgument(promisify, parameter, index, hasSeenOptional) };
 };
 
 const collectPromisifiedArguments = (promisify: PromisifyContext, cancellableIndex: number): string[] => {
     const expressions: string[] = [];
-    let isSawOptional = false;
+    let hasSeenOptional = false;
 
     for (const [index, parameter] of promisify.asyncFn.parameters.entries()) {
         const step = classifyPromisifiedParameter(promisify, parameter, index, {
             cancellableIndex,
-            sawOptional: isSawOptional,
+            hasSeenOptional,
         });
 
-        isSawOptional = step.sawOptional;
+        hasSeenOptional = step.hasSeenOptional;
 
         if (step.expression !== undefined) {
             expressions.push(step.expression);
@@ -298,12 +298,12 @@ const paramDescriptorLiteral = (descriptor: string, options: ParamDescriptorOpti
         parts.push(`direction: ${sourceStringLiteral(options.direction)}`);
     }
 
-    if (options.callerAllocated === true) {
-        parts.push("callerAllocated: true");
+    if (options.isCallerAllocated === true) {
+        parts.push("isCallerAllocated: true");
     }
 
-    if (options.consumed === true) {
-        parts.push("consumed: true");
+    if (options.isConsumed === true) {
+        parts.push("isConsumed: true");
     }
 
     return `{ ${parts.join(", ")} }`;
@@ -315,6 +315,7 @@ const renderReturnDescriptor = (context: ModuleContext, fn: GirFunction): string
     return renderDescriptor(context, fn.returnValue.type, fn.returnValue.transferOwnership, {
         argIndexOffset: instanceOffset,
         argIndexMap: emittedArgIndices(fn, instanceOffset),
+        isNewlyCreated: fn.instance === undefined,
     });
 };
 
@@ -406,7 +407,7 @@ const planInoutArgument = (
     return planInoutParam(context, parameter, {
         index,
         argIndex: planContext.argIndex,
-        consumed: folded.has(index),
+        isConsumed: folded.has(index),
         lengthSource,
     });
 };
@@ -435,7 +436,7 @@ const planOutParam = (
     const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, argIndex);
 
     return {
-        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", consumed: isConsumed }),
+        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", isConsumed }),
         inputExpr: undefined,
     };
 };
@@ -473,7 +474,7 @@ const planCallerOut = (
         const classExpression = context.qualify(name.namespaceName, name.typeName);
 
         return {
-            paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", callerAllocated: true }),
+            paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", isCallerAllocated: true }),
             inputExpr: `new ${classExpression}()`,
         };
     }
@@ -487,17 +488,21 @@ const planInoutParam = (
     options: {
         index: number;
         argIndex: ArgIndexOptions;
-        consumed: boolean;
+        isConsumed: boolean;
         lengthSource?: { source: GirParameter; index: number } | undefined;
     },
 ): CallArgPlan => {
-    const { index, argIndex, consumed, lengthSource } = options;
+    const { index, argIndex, isConsumed, lengthSource } = options;
 
     if (isHandlePassedInPlace(context, parameter)) {
         const descriptor = renderDescriptor(context, parameter.type, "none", argIndex);
 
         return {
-            paramLiteral: paramDescriptorLiteral(descriptor, { direction: "inout", callerAllocated: true, consumed }),
+            paramLiteral: paramDescriptorLiteral(descriptor, {
+                direction: "inout",
+                isCallerAllocated: true,
+                isConsumed,
+            }),
             inputExpr: parameterIdentifier(parameter, index),
         };
     }
@@ -505,7 +510,7 @@ const planInoutParam = (
     const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, argIndex);
 
     return {
-        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "inout", consumed }),
+        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "inout", isConsumed }),
         inputExpr:
             lengthSource === undefined
                 ? parameterCallExpression(context, parameter, index)
@@ -587,8 +592,6 @@ const collectionArgument = (
     return mapHandleExpression(name, isNullable);
 };
 
-// An array whose length nothing states is marshalled as the bare pointer it is, so there is nothing
-// to map over.
 const isMappableSequence = (context: ModuleContext, type: GirType | undefined): boolean => {
     if (type?.kind === "carray") {
         return !hasUnknownArrayLength(type) && isHandlePassing(context, type.element);

package/src/store/gi/property-accessor.ts

@@ -15,7 +15,7 @@ type ResolvedAccessor = {
     jsName: string;
     tsType: string;
     hasGetter: boolean;
-    writable: boolean;
+    isWritable: boolean;
     getterMember: string | undefined;
     getterMethod: GirFunction | undefined;
     setterMember: string | undefined;
@@ -136,8 +136,6 @@ const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefin
         return undefined;
     }
 
-    // `g_object_set_property` rejects a construct-only pspec with a critical and drops the write, so
-    // the property is settable at construction time only and must not advertise a setter.
     const isWritable = isConstructableProperty(property) && !property.constructOnly;
     const { member: getterMember, method: getterMethod } = resolveGetterDelegate(args, jsName);
     const { member: setterMember, method: setterMethod } = resolveSetterDelegate(args, jsName, isWritable);
@@ -150,7 +148,7 @@ const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefin
     const ownType = resolveOwnType(context, property, getterMethod, setterMethod);
     const tsType = resolveTsType(args.inheritedType, ownType);
 
-    return { jsName, tsType, hasGetter, writable: isWritable, getterMember, getterMethod, setterMember };
+    return { jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember };
 };
 
 const resolveOwnerAccessor = (
@@ -197,7 +195,7 @@ const renderResolvedPropertyAccessor = (
     property: GirProperty,
     accessor: ResolvedAccessor,
 ): string => {
-    const { jsName, tsType, hasGetter, writable, getterMember, getterMethod, setterMember } = accessor;
+    const { jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember } = accessor;
     const blocks: string[] = [];
 
     if (hasGetter) {
@@ -205,7 +203,7 @@ const renderResolvedPropertyAccessor = (
         blocks.push(renderBlock(`get ${jsName}(): ${tsType}`, getterBody));
     }
 
-    if (writable) {
+    if (isWritable) {
         const setterBody =
             setterMember === undefined ? renderGenericSetBody(context, property) : `this.${setterMember}(value);`;
 
@@ -219,10 +217,10 @@ const renderPropertyAccessor = (args: PropertyAccessorArgs): string | undefined
     withAccessor(args, (accessor) => renderResolvedPropertyAccessor(args.context, args.property, accessor));
 
 const renderPropertyAccessorSignature = (args: PropertyAccessorArgs): string | undefined =>
-    withAccessor(args, ({ jsName, tsType, hasGetter, writable }) => {
+    withAccessor(args, ({ jsName, tsType, hasGetter, isWritable }) => {
         const doc = renderJsDoc(args.property.doc);
 
-        if (hasGetter && writable) {
+        if (hasGetter && isWritable) {
             return `${doc}${jsName}: ${tsType};`;
         }
 

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

@@ -7,8 +7,9 @@ import { renderDescriptor } from "../../analysis/descriptor-render.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
 import { renderSourceGtype } from "./gtype-binding.js";
-import { emitFieldWrite, isEmittableField } from "./record-field-accessor.js";
+import { emitFieldWrite, isEmittableField, isInlineField } from "./record-field-accessor.js";
 import { computeRecordFieldSlots, type RecordFieldSlot } from "./record-layout.js";
+import { isConstructibleRecord } from "./value-marshalable.js";
 
 type WritableFieldSlot = RecordFieldSlot & { field: GirField & { type: TypeId } };
 
@@ -24,7 +25,7 @@ const renderRecordConstructorPropsInterface = (
 ): string => {
     const head = `export interface ${className}ConstructorProps`;
 
-    if (isOpaque(record)) {
+    if (isOpaque(record) || !isConstructibleRecord(context, context.namespace.name, record)) {
         return renderBracedOrEmpty(head, "");
     }
 
@@ -68,7 +69,7 @@ const renderRecordConstructor = (
 ): string => {
     const superCall = isErrorSubclass ? ["super();"] : [];
 
-    if (isOpaque(record)) {
+    if (isOpaque(record) || !isConstructibleRecord(context, context.namespace.name, record)) {
         return renderOpaqueConstructor(className, superCall);
     }
 
@@ -103,7 +104,11 @@ const allocArgs = (context: ModuleContext, record: GirRecord, size: number): str
 
 const renderFieldWrite = (context: ModuleContext, entry: WritableFieldSlot): string => {
     context.addRuntimeImport("t");
-    const descriptor = context.hoistDescriptor(renderDescriptor(context, entry.field.type, "none"));
+
+    const descriptor = context.hoistDescriptor(
+        renderDescriptor(context, entry.field.type, "none", { isInline: isInlineField(context, entry.field) }),
+    );
+
     const name = toCamelIdentifier(entry.field.name);
 
     const write = emitFieldWrite(context, {

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

@@ -9,9 +9,9 @@ import { tStruct } from "../../analysis/descriptor.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { indent, renderBlock } from "../../writer/emit.js";
-import { isClassStructRef } from "./class-struct-record.js";
 import { bitMask, computeRecordFieldSlots, mergeBitfield, type RecordFieldSlot } from "./record-layout.js";
 import { wrapReturnValue } from "./return-wrap.js";
+import { isValueMarshalable } from "./value-marshalable.js";
 
 type FieldWriteSpec = {
     descriptor: string;
@@ -28,7 +28,7 @@ type AdmittedField = {
 type RecordFieldEntry = {
     jsName: string;
     tsType: string;
-    writable: boolean;
+    isWritable: boolean;
     doc: string | undefined;
 };
 
@@ -91,18 +91,37 @@ type AccessorOptions = {
     fieldType: TypeId;
 };
 
+const isMarshalableField = (context: ModuleContext, field: GirField): boolean => {
+    if (field.cType?.endsWith("*") === true) {
+        return true;
+    }
+
+    const type = field.type === undefined ? undefined : context.library.typeFor(field.type);
+
+    if (type?.kind !== "record") {
+        return true;
+    }
+
+    return isValueMarshalable(context, type.namespace.name, type.value);
+};
+
 const isEmittableField = (context: ModuleContext, field: GirField): field is GirField & { type: TypeId } =>
     !field.private &&
     field.type !== undefined &&
     !isInlineCallbackRef(context.library, field.type) &&
-    !isClassStructRef(context, field.type);
+    isMarshalableField(context, field);
 
 const emitFieldWrite = (context: ModuleContext, spec: FieldWriteSpec): string => {
     const { descriptor, slot, targetExpr, valueExpr } = spec;
     context.addRuntimeImport("write");
 
     if (slot.bitWidth === undefined) {
-        return `write(${targetExpr}, ${descriptor}, ${String(slot.byteOffset)}, ${valueExpr});`;
+        context.addRuntimeImport("toNative");
+
+        return (
+            `write(${targetExpr}, ${descriptor}, ${String(slot.byteOffset)}, ` +
+            `toNative(${descriptor}, ${valueExpr}));`
+        );
     }
 
     context.addRuntimeImport("read");
@@ -159,7 +178,7 @@ const resolveRecordFieldEntry = (
     return {
         jsName: admitted.jsName,
         tsType: renderTsType(context, admitted.field.type, false),
-        writable: admitted.field.writable,
+        isWritable: admitted.field.writable,
         doc: admitted.field.doc,
     };
 };
@@ -190,10 +209,10 @@ const renderRecordFieldAccessor = (
         return `${doc}declare ${jsName}: ${tsType};`;
     }
 
-    // A record field whose C type is the record itself rather than a pointer to it holds the value
-    // in place, so its own address is the value and no word may be loaded out of it.
-    const isInline = resolveInlineStructFields(context, field.type, field.cType) !== undefined;
-    const descriptor = context.hoistDescriptor(renderDescriptor(context, field.type, "none", { isInline }));
+    const descriptor = context.hoistDescriptor(
+        renderDescriptor(context, field.type, "none", { isInline: isInlineField(context, field) }),
+    );
+
     const tsType = renderTsType(context, field.type, false);
 
     const accessorOptions: AccessorOptions = {
@@ -246,6 +265,9 @@ const isAccessorEligibleType = (context: ModuleContext, ref: TypeId): boolean =>
     }
 };
 
+const isInlineField = (context: ModuleContext, field: GirField): boolean =>
+    field.type !== undefined && resolveInlineStructFields(context, field.type, field.cType) !== undefined;
+
 const resolveInlineStructFields = (
     context: ModuleContext,
     ref: TypeId | undefined,
@@ -543,7 +565,7 @@ const renderStructArrayAccessor = (context: ModuleContext, target: StructArrayTa
         elementDescriptor: tStruct("borrowed", {
             size: `${lengthExpr} * ${String(elementSize)}`,
             wrapperClass: undefined,
-            callerAllocated: false,
+            isCallerAllocated: false,
         }),
         offset: slot.byteOffset,
         lengthExpr,
@@ -575,7 +597,7 @@ const getterBlock = (options: AccessorOptions): string => {
 
         const wrapped = wrapReturnValue(context, {
             ref: fieldType,
-            nullable: false,
+            isNullable: false,
             valueExpression,
         });
 
@@ -604,4 +626,11 @@ const setterBlock = (options: AccessorOptions): string =>
         setterBody(options.context, options.descriptor, options.slot),
     );
 
-export { isEmittableField, emitFieldWrite, resolveRecordFieldEntry, renderRecordFieldAccessor, type RecordFieldEntry };
+export {
+    isEmittableField,
+    isInlineField,
+    emitFieldWrite,
+    resolveRecordFieldEntry,
+    renderRecordFieldAccessor,
+    type RecordFieldEntry,
+};

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

@@ -20,10 +20,6 @@ type RecordFieldSlot = {
 const POINTER_LAYOUT: FieldLayout = { size: 8, align: 8 };
 const recordLayoutCache: Map<string, FieldLayout> = new Map();
 
-// GIR carries no alignment attribute, and a type whose alignment exceeds its widest member cannot be
-// derived from the field list: Graphene models `graphene_simd4f_t` as four `gfloat`, which computes
-// to align 4 while the real type is a 16-byte SIMD vector. Keying the override on `c:type` keeps it
-// to the handful of types where the XML genuinely cannot express the ABI.
 const ALIGNMENT_OVERRIDES: Map<string, FieldLayout> = new Map([
     ["graphene_simd4f_t", { size: 16, align: 16 }],
     ["graphene_simd4x4f_t", { size: 64, align: 16 }],

package/src/store/gi/record.ts

@@ -3,7 +3,6 @@ import type { ModuleContext } from "../../writer/context.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { indentMembers } from "../../writer/emit.js";
 import { type Callables, dedupeCallables, generateBindings, renderPlainTypeMembers } from "./callables.js";
-import { isClassStructRecord } from "./class-struct-record.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { renderRecordConstructor, renderRecordConstructorPropsInterface } from "./record-constructor.js";
 import { renderRecordFieldAccessor } from "./record-field-accessor.js";
@@ -18,18 +17,10 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
         return;
     }
 
-    if (record.isVtable) {
-        return;
-    }
-
     if (record.name.length === 0) {
         return;
     }
 
-    if (isClassStructRecord(context.library, context.namespace.name, record)) {
-        return;
-    }
-
     const className = record.name;
     const isErrorSubclass = isGErrorRecord(context, record);
 

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

@@ -6,14 +6,14 @@ import { renderTsType } from "../../analysis/ts-type.js";
 
 type WrapReturnOptions = {
     ref: TypeId | undefined;
-    nullable: boolean;
+    isNullable: boolean;
     valueExpression: string;
 };
 
 const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["gtype", "bigint64", "biguint64"]);
 
 const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): string => {
-    const { ref, nullable, valueExpression } = options;
+    const { ref, isNullable, valueExpression } = options;
 
     if (ref === undefined) {
         return valueExpression;
@@ -27,7 +27,7 @@ const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): st
 
     switch (type.kind) {
         case "primitive": {
-            return wrapPrimitive(type.category, nullable, valueExpression);
+            return wrapPrimitive(type.category, isNullable, valueExpression);
         }
         case "varargs": {
             return `(${valueExpression} as unknown[])`;
@@ -39,7 +39,7 @@ const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): st
             return `(${valueExpression} as number)`;
         }
         case "alias": {
-            return wrapAlias(context, type.value.target, nullable, valueExpression);
+            return wrapAlias(context, type.value.target, isNullable, valueExpression);
         }
         case "carray":
         case "class":
@@ -65,7 +65,7 @@ const wrapAlias = (
 ): string =>
     target === undefined
         ? valueExpression
-        : wrapReturnValue(context, { ref: target, nullable: isNullable, valueExpression });
+        : wrapReturnValue(context, { ref: target, isNullable, valueExpression });
 
 const wrapValue = (context: ModuleContext, ref: TypeId, valueExpression: string): string => {
     context.addRuntimeImport("fromNative");