@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.3

package/dist/analysis/descriptor-render.d.ts

@@ -1,18 +1,27 @@
 import type { Library } from "../gir/library.js";
-import { type GirParameter, type GirReturnValue, type ParameterTransfer } from "../gir/parameter.js";
-import type { TypeId } from "../gir/type-id.js";
 import type { ModuleContext } from "../writer/context.js";
+import { type GirParameter, type GirReturnValue, type ParameterTransfer } from "../gir/parameter.js";
+import { type TypeId } from "../gir/type-id.js";
 type RenderDescriptorOptions = {
     argIndexOffset?: number;
+    /** GIR parameter index to emitted argument index, for callables that drop parameters. */
+    argIndexMap?: Map<number, number> | undefined;
     callerAllocated?: boolean;
+    isInline?: boolean;
+    /** Set on the return value of a callable with no instance parameter, which creates what it returns. */
+    isNewlyCreated?: boolean;
+};
+type ArgIndexOptions = {
+    argIndexOffset: number;
+    argIndexMap: Map<number, number> | undefined;
 };
-export declare const isInlineCallbackRef: (library: Library, ref: TypeId | undefined) => boolean;
-export declare const omitsPrimaryReturn: (library: Library, returnValue: GirReturnValue) => boolean;
-export declare const renderDescriptor: (context: ModuleContext, ref: TypeId | undefined, transfer?: ParameterTransfer, options?: RenderDescriptorOptions) => string;
-export declare const isScalarRef: (library: Library, ref: TypeId | undefined) => boolean;
-export declare const isCellInout: (library: Library, parameter: GirParameter) => boolean;
-export declare const renderParamDescriptor: (context: ModuleContext, parameter: GirParameter, ref: TypeId | undefined) => string;
-export declare const renderCallbackType: (context: ModuleContext, ref: TypeId | undefined, owningParameter: GirParameter, argOverrides?: Map<number, string>) => string | undefined;
-export declare const renderSelfDescriptor: (context: ModuleContext, instance: GirParameter) => string;
-export {};
+declare const isInlineCallbackRef: (library: Library, ref: TypeId | undefined) => boolean;
+declare const shouldOmitPrimaryReturn: (library: Library, returnValue: GirReturnValue) => boolean;
+declare const renderDescriptor: (context: ModuleContext, ref: TypeId | undefined, transfer?: ParameterTransfer, options?: RenderDescriptorOptions) => string;
+declare const isScalarRef: (library: Library, ref: TypeId | undefined) => boolean;
+declare const isCellInout: (library: Library, parameter: GirParameter) => boolean;
+declare const renderParamDescriptor: (context: ModuleContext, parameter: GirParameter, ref: TypeId | undefined, argIndex?: Partial<ArgIndexOptions>) => string;
+declare const renderCallbackType: (context: ModuleContext, ref: TypeId | undefined, owningParameter: GirParameter, argOverrides?: Map<number, string>) => string | undefined;
+declare const renderSelfDescriptor: (context: ModuleContext, instance: GirParameter) => string;
+export { isInlineCallbackRef, shouldOmitPrimaryReturn, renderDescriptor, isScalarRef, isCellInout, renderParamDescriptor, renderCallbackType, renderSelfDescriptor, };
 //# sourceMappingURL=descriptor-render.d.ts.map

package/dist/analysis/descriptor-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"descriptor-render.d.ts","sourceRoot":"","sources":["../../src/analysis/descriptor-render.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,cAAc,EAInB,KAAK,iBAAiB,EACzB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAA0B,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAqC1D,KAAK,uBAAuB,GAAG;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAQF,eAAO,MAAM,mBAAmB,YAAa,OAAO,OAAO,MAAM,GAAG,SAAS,KAAG,OACsB,CAAC;AAEvG,eAAO,MAAM,kBAAkB,YAAa,OAAO,eAAe,cAAc,KAAG,OACvB,CAAC;AAE7D,eAAO,MAAM,gBAAgB,YAChB,aAAa,OACjB,MAAM,GAAG,SAAS,aACb,iBAAiB,YAClB,uBAAuB,KACjC,MAkCF,CAAC;AASF,eAAO,MAAM,WAAW,YAAa,OAAO,OAAO,MAAM,GAAG,SAAS,KAAG,OAQvE,CAAC;AAEF,eAAO,MAAM,WAAW,YAAa,OAAO,aAAa,YAAY,KAAG,OACD,CAAC;AAExE,eAAO,MAAM,qBAAqB,YACrB,aAAa,aACX,YAAY,OAClB,MAAM,GAAG,SAAS,KACxB,MAUF,CAAC;AAEF,eAAO,MAAM,kBAAkB,YAClB,aAAa,OACjB,MAAM,GAAG,SAAS,mBACN,YAAY,iBACd,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KACnC,MAAM,GAAG,SAoBX,CAAC;AAuFF,eAAO,MAAM,oBAAoB,YAAa,aAAa,YAAY,YAAY,KAAG,MAarF,CAAC"}
+{"version":3,"file":"descriptor-render.d.ts","sourceRoot":"","sources":["../../src/analysis/descriptor-render.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,cAAc,EAInB,KAAK,iBAAiB,EACzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAKH,KAAK,MAAM,EACd,MAAM,mBAAmB,CAAC;AA+B3B,KAAK,uBAAuB,GAAG;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yFAAyF;IACzF,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAC9C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uGAAuG;IACvG,cAAc,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,KAAK,eAAe,GAAG;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CAChD,CAAC;AAiFF,QAAA,MAAM,mBAAmB,GAAI,SAAS,OAAO,EAAE,KAAK,MAAM,GAAG,SAAS,KAAG,OAC+B,CAAC;AAEzG,QAAA,MAAM,uBAAuB,GAAI,SAAS,OAAO,EAAE,aAAa,cAAc,KAAG,OACrB,CAAC;AAE7D,QAAA,MAAM,gBAAgB,GAClB,SAAS,aAAa,EACtB,KAAK,MAAM,GAAG,SAAS,EACvB,WAAU,iBAA0B,EACpC,UAAS,uBAA4B,KACtC,MAgDF,CAAC;AAyDF,QAAA,MAAM,WAAW,GAAI,SAAS,OAAO,EAAE,KAAK,MAAM,GAAG,SAAS,KAAG,OAQhE,CAAC;AAEF,QAAA,MAAM,WAAW,GAAI,SAAS,OAAO,EAAE,WAAW,YAAY,KAAG,OACM,CAAC;AAExE,QAAA,MAAM,qBAAqB,GACvB,SAAS,aAAa,EACtB,WAAW,YAAY,EACvB,KAAK,MAAM,GAAG,SAAS,EACvB,WAAU,OAAO,CAAC,eAAe,CAAM,KACxC,MAaF,CAAC;AAyCF,QAAA,MAAM,kBAAkB,GACpB,SAAS,aAAa,EACtB,KAAK,MAAM,GAAG,SAAS,EACvB,iBAAiB,YAAY,EAC7B,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KACnC,MAAM,GAAG,SAoBX,CAAC;AAkIF,QAAA,MAAM,oBAAoB,GAAI,SAAS,aAAa,EAAE,UAAU,YAAY,KAAG,MAsB9E,CAAC;AA2OF,OAAO,EACH,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,GACvB,CAAC"}

package/dist/analysis/descriptor-render.js

@@ -1,292 +1,435 @@
 import { sourceStringLiteral } from "@gtkx/utils";
 import { isCallerAllocatedOut, isInoutParameter, isOutParameter, } from "../gir/parameter.js";
+import { hasUnknownArrayLength, } from "../gir/type-id.js";
 import { isRecordInout } from "../store/gi/param-marshal.js";
 import { computeRecordFieldSlots } from "../store/gi/record-layout.js";
+import { isValueMarshalable } from "../store/gi/value-marshalable.js";
 import { tArray, tBoxed, tByteArray, tCallback, tEnum, tFixedArray, tFlags, tFundamental, tGtype, tHashTable, tInt32, tList, tObject, tRef, tScalar, tSizedArray, tString, tStruct, tUint32, tUint64, tVoid, } from "./descriptor.js";
+const LIST_HELPERS = {
+    glist: "list",
+    gslist: "slist",
+    gptrarray: "ptrArray",
+    garray: "gArray",
+};
+/**
+ * `glib:type-name` of every fundamental whose instances are born with a floating reference, so a
+ * callable that creates one hands back a claim nobody has taken rather than an owned reference.
+ * GIR annotates those returns `transfer-ownership="full"` all the same, so the annotation alone
+ * cannot tell them apart from a genuinely owned return such as `g_param_spec_ref`.
+ */
+const FLOATING_FUNDAMENTALS = new Set(["GParam"]);
+// A callable that drops parameters (varargs, and the closure/destroy slots folded into a callback)
+// shifts every later parameter left, so a GIR length index has to be looked up in the emitted list
+// rather than shifted by the instance offset alone.
+const mapArgIndex = (options, girIndex) => options.argIndexMap?.get(girIndex) ?? girIndex + options.argIndexOffset;
 const transferOwnership = (transfer) => {
-    if (transfer === "full")
+    if (transfer === "full") {
         return "full";
-    if (transfer === "container")
+    }
+    if (transfer === "container") {
         return "full";
+    }
     return "borrowed";
 };
 const deriveElementTransfer = (transfer) => transfer === "container" ? "none" : transfer;
 const isVoidRef = (library, ref) => {
-    if (ref === undefined)
+    if (ref === undefined) {
         return true;
-    const type = library.typeOf(ref);
+    }
+    const type = library.typeFor(ref);
     return type?.kind === "primitive" && type.category === "void";
 };
-export const isInlineCallbackRef = (library, ref) => ref !== undefined && library.typeOf(ref)?.kind === "callback" && library.nameOf(ref) === undefined;
-export const omitsPrimaryReturn = (library, returnValue) => isVoidRef(library, returnValue.type) || returnValue.skip;
-export const renderDescriptor = (context, ref, transfer = "none", options = {}) => {
-    if (ref === undefined)
+const isInlineCallbackRef = (library, ref) => ref !== undefined && library.typeFor(ref)?.kind === "callback" && library.nameFor(ref) === undefined;
+const shouldOmitPrimaryReturn = (library, returnValue) => isVoidRef(library, returnValue.type) || returnValue.skip;
+const renderDescriptor = (context, ref, transfer = "none", options = {}) => {
+    if (ref === undefined) {
         return tVoid;
+    }
     const { argIndexOffset = 0 } = options;
+    const indexOptions = { argIndexOffset, argIndexMap: options.argIndexMap };
     const ownership = transferOwnership(transfer);
-    const type = context.library.typeOf(ref);
-    if (type === undefined)
+    const type = context.library.typeFor(ref);
+    if (type === undefined) {
         return tObject(ownership);
+    }
     switch (type.kind) {
-        case "primitive":
+        case "primitive": {
             return primitiveExpression(type.category, ownership);
-        case "varargs":
-        case "callback":
+        }
+        case "varargs": {
             return tVoid;
+        }
+        // A callback in a slot no `renderCallbackType` covers (a vtable entry, a signal argument, a
+        // record field) is still a function pointer occupying a pointer-sized slot. `t.void` would
+        // hand the implementation `undefined` where the pointer belongs.
+        case "callback": {
+            return tUint64;
+        }
         case "class":
         case "interface":
         case "record":
         case "enum":
-        case "alias":
+        case "alias": {
             return expressionForResolved(context, type, transfer, options);
-        case "carray":
-            return arrayExpression(context, type, transfer, argIndexOffset);
+        }
+        case "carray": {
+            return arrayExpression(context, type, transfer, indexOptions);
+        }
         case "list": {
-            if (type.flavor === "gbytearray")
-                return tByteArray(ownership);
-            const element = renderDescriptor(context, type.element, deriveElementTransfer(transfer), {
-                argIndexOffset,
-            });
-            return tList(LIST_HELPERS[type.flavor], element, ownership);
+            return listExpression(context, type, transfer, indexOptions);
         }
         case "hashtable": {
             const elementTransfer = deriveElementTransfer(transfer);
-            const key = renderDescriptor(context, type.key, elementTransfer, { argIndexOffset });
-            const value = renderDescriptor(context, type.value, elementTransfer, { argIndexOffset });
+            const key = renderDescriptor(context, type.key, elementTransfer, indexOptions);
+            const value = renderDescriptor(context, type.value, elementTransfer, indexOptions);
             return tHashTable(key, value, ownership);
         }
     }
 };
+const listExpression = (context, type, transfer, indexOptions) => {
+    const ownership = transferOwnership(transfer);
+    if (type.flavor === "gbytearray") {
+        return tByteArray(ownership);
+    }
+    const element = renderDescriptor(context, type.element, deriveElementTransfer(transfer), indexOptions);
+    return tList(LIST_HELPERS[type.flavor], element, ownership);
+};
 const resolveCallbackType = (context, ref) => {
-    if (ref === undefined)
+    if (ref === undefined) {
         return undefined;
-    const type = context.library.typeOf(ref);
-    if (type?.kind !== "callback")
+    }
+    const type = context.library.typeFor(ref);
+    if (type?.kind !== "callback") {
         return undefined;
+    }
     return type.value;
 };
-export const isScalarRef = (library, ref) => {
-    if (ref === undefined)
-        return false;
-    const type = library.typeOf(ref);
-    if (type === undefined)
+const isScalarType = (library, type) => {
+    switch (type.kind) {
+        case "primitive": {
+            return type.category !== "string" && type.category !== "void";
+        }
+        case "enum": {
+            return true;
+        }
+        case "alias": {
+            return type.value.target !== undefined && isScalarRef(library, type.value.target);
+        }
+        case "callback":
+        case "carray":
+        case "class":
+        case "hashtable":
+        case "interface":
+        case "list":
+        case "record":
+        case "varargs": {
+            return false;
+        }
+    }
+};
+const isScalarRef = (library, ref) => {
+    if (ref === undefined) {
         return false;
-    if (type.kind === "primitive")
-        return type.category !== "string" && type.category !== "void";
-    if (type.kind === "enum")
-        return true;
-    if (type.kind === "alias")
-        return type.value.target !== undefined && isScalarRef(library, type.value.target);
-    return false;
+    }
+    const type = library.typeFor(ref);
+    return type !== undefined && isScalarType(library, type);
 };
-export const isCellInout = (library, parameter) => isInoutParameter(parameter) && isScalarRef(library, parameter.type);
-export const renderParamDescriptor = (context, parameter, ref) => {
+const isCellInout = (library, parameter) => isInoutParameter(parameter) && isScalarRef(library, parameter.type);
+const renderParamDescriptor = (context, parameter, ref, argIndex = {}) => {
     if (isCellInout(context.library, parameter)) {
-        return tRef(renderDescriptor(context, ref, parameter.transferOwnership), true);
+        return tRef(renderDescriptor(context, ref, parameter.transferOwnership, argIndex), true);
     }
     if (isOutParameter(parameter)) {
-        return tRef(renderDescriptor(context, ref, parameter.transferOwnership));
+        return tRef(renderDescriptor(context, ref, parameter.transferOwnership, argIndex));
     }
     return renderDescriptor(context, ref, parameter.transferOwnership, {
+        ...argIndex,
         callerAllocated: isCallerAllocatedOut(parameter) || isRecordInout(context, parameter),
     });
 };
-export const renderCallbackType = (context, ref, owningParameter, argOverrides) => {
+// `closure=` on a callback's own parameter states which slot carries the user data, and it is what
+// the TypeScript signature already goes by. The name scan stays as a fallback: 88 callbacks across
+// the installed GIRs carry no `closure=` at all.
+const userDataIndexByName = (parameters) => {
+    let userDataIndex;
+    for (const [index, parameter] of parameters.entries()) {
+        if (parameter.name === "user_data" || parameter.name === "data") {
+            userDataIndex = index;
+        }
+    }
+    return userDataIndex;
+};
+const findUserDataIndex = (parameters) => {
+    const declared = parameters.find((parameter) => parameter.closureIndex !== undefined);
+    return declared?.closureIndex ?? userDataIndexByName(parameters);
+};
+const callbackOptionsArg = (owningParameter, userDataIndex) => {
+    const options = [];
+    if (owningParameter.destroyIndex !== undefined) {
+        options.push("hasDestroy: true");
+    }
+    if (userDataIndex !== undefined) {
+        options.push(`userDataIndex: ${String(userDataIndex)}`);
+    }
+    if (owningParameter.scope !== undefined) {
+        options.push(`scope: ${sourceStringLiteral(owningParameter.scope)}`);
+    }
+    return options.length > 0 ? `{ ${options.join(", ")} }` : undefined;
+};
+const renderCallbackType = (context, ref, owningParameter, argOverrides) => {
     const callback = resolveCallbackType(context, ref);
-    if (callback === undefined)
+    if (callback === undefined) {
         return undefined;
+    }
     const argTypes = callback.parameters.map((parameter, index) => argOverrides?.get(index) ?? renderParamDescriptor(context, parameter, parameter.type));
-    let userDataIndex;
-    callback.parameters.forEach((parameter, index) => {
-        if (parameter.name === "user_data" || parameter.name === "data")
-            userDataIndex = index;
-    });
     const returnRef = callback.returnValue.type;
     const returnType = isVoidRef(context.library, returnRef)
         ? tVoid
         : renderDescriptor(context, returnRef, callback.returnValue.transferOwnership);
-    const options = [];
-    if (owningParameter.destroyIndex !== undefined)
-        options.push("hasDestroy: true");
-    if (userDataIndex !== undefined)
-        options.push(`userDataIndex: ${userDataIndex}`);
-    if (owningParameter.scope !== undefined)
-        options.push(`scope: ${sourceStringLiteral(owningParameter.scope)}`);
-    const optionsArg = options.length > 0 ? `{ ${options.join(", ")} }` : undefined;
+    const optionsArg = callbackOptionsArg(owningParameter, findUserDataIndex(callback.parameters));
     return tCallback(argTypes, returnType, optionsArg);
 };
-const LIST_HELPERS = {
-    glist: "list",
-    gslist: "slist",
-    gptrarray: "ptrArray",
-    garray: "gArray",
-};
 const primitiveExpression = (category, ownership) => {
-    if (category === "void")
+    if (category === "void") {
         return tVoid;
-    if (category === "string")
+    }
+    if (category === "string") {
         return tString(ownership);
-    if (category === "pointer")
+    }
+    if (category === "pointer") {
         return tUint64;
-    if (category === "gtype")
+    }
+    if (category === "gtype") {
         return tGtype;
+    }
     return tScalar(category);
 };
-const referenceAddingFunc = (refFunc) => refFunc.endsWith("_ref_sink") ? refFunc.slice(0, -"_sink".length) : refFunc;
 const renderFundamental = (descriptor) => {
-    const { lib, refFunc, unrefFunc, typeName, ownership, wrapperClass } = descriptor;
-    return tFundamental(lib, referenceAddingFunc(refFunc), unrefFunc, {
+    const { lib, refFunc, unrefFunc, typeName, ownership, wrapperClass, inline } = descriptor;
+    return tFundamental(lib, refFunc, unrefFunc, {
         ownership,
         typeName,
         wrapperClass,
+        inline,
     });
 };
-const classOrInterfaceExpression = (resolved, ownership) => {
-    const cls = resolved.value;
-    if (cls.glibRefFunc === undefined || cls.glibUnrefFunc === undefined) {
+// A freshly created floating instance is claimed by sinking it, which is what the fundamental's
+// declared ref function does, so it is marshalled as transfer-none: adopting the floating reference
+// instead would leave the handle releasing a claim it never took.
+const sunkOwnership = (ancestor, ownership, isNewlyCreated) => {
+    if (!isNewlyCreated || ownership !== "full" || ancestor.typeName === undefined) {
+        return ownership;
+    }
+    return FLOATING_FUNDAMENTALS.has(ancestor.typeName) ? "borrowed" : ownership;
+};
+// GIR marks only the root of a fundamental hierarchy with `glib:fundamental` and its ref/unref pair,
+// so a derived type such as GtkPropertyExpression carries neither and has to inherit both.
+const classOrInterfaceExpression = (context, resolved, ownership, isNewlyCreated) => {
+    const ancestor = fundamentalAncestor(context, resolved);
+    if (ancestor === undefined) {
         return tObject(ownership);
     }
-    return renderFundamental({
-        lib: resolved.namespace.sharedLibrary ?? "",
+    return renderFundamental({ ...ancestor, ownership: sunkOwnership(ancestor, ownership, isNewlyCreated) });
+};
+const isClassOrInterface = (type) => type !== undefined && (type.kind === "class" || type.kind === "interface");
+const getFundamental = (node) => {
+    const cls = node.value;
+    if (!cls.fundamental || cls.glibRefFunc === undefined || cls.glibUnrefFunc === undefined) {
+        return undefined;
+    }
+    return {
+        lib: node.namespace.sharedLibrary ?? "",
         refFunc: cls.glibRefFunc,
         unrefFunc: cls.glibUnrefFunc,
         typeName: cls.glibTypeName,
-        ownership,
-    });
+    };
 };
-const fundamentalAncestor = (context, start) => {
-    const seen = new Set();
-    let current = start;
-    while (current !== undefined && (current.kind === "class" || current.kind === "interface")) {
-        const key = `${current.namespace.name}.${current.value.name}`;
-        if (seen.has(key))
-            return undefined;
-        seen.add(key);
-        const cls = current.value;
-        if (cls.fundamental && cls.glibRefFunc !== undefined && cls.glibUnrefFunc !== undefined) {
-            return {
-                lib: current.namespace.sharedLibrary ?? "",
-                refFunc: cls.glibRefFunc,
-                unrefFunc: cls.glibUnrefFunc,
-                typeName: cls.glibTypeName,
-            };
-        }
-        if (cls.parent === undefined)
-            return undefined;
-        current = context.library.resolveType(current.namespace.name, cls.parent);
+const walkFundamental = (context, current, seen) => {
+    if (!isClassOrInterface(current)) {
+        return undefined;
+    }
+    const key = `${current.namespace.name}.${current.value.name}`;
+    if (seen.has(key)) {
+        return undefined;
+    }
+    seen.add(key);
+    const fundamental = getFundamental(current);
+    if (fundamental !== undefined) {
+        return fundamental;
     }
-    return undefined;
+    if (current.value.parent === undefined) {
+        return undefined;
+    }
+    const parent = context.library.resolveType(current.namespace.name, current.value.parent);
+    return walkFundamental(context, parent, seen);
 };
-export const renderSelfDescriptor = (context, instance) => {
+const fundamentalAncestor = (context, start) => walkFundamental(context, start, new Set());
+const classSelfDescriptor = (context, type) => {
+    const ancestor = fundamentalAncestor(context, type);
+    return ancestor === undefined ? tObject("borrowed") : renderFundamental({ ...ancestor, ownership: "borrowed" });
+};
+const renderSelfDescriptor = (context, instance) => {
     const ref = instance.type;
-    if (ref === undefined)
+    if (ref === undefined) {
         return tObject("borrowed");
-    const type = context.library.typeOf(ref);
-    if (type === undefined)
+    }
+    const type = context.library.typeFor(ref);
+    if (type === undefined) {
         return tObject("borrowed");
-    if (type.kind === "class" || type.kind === "interface") {
-        const ancestor = fundamentalAncestor(context, type);
-        return ancestor === undefined ? tObject("borrowed") : renderFundamental({ ...ancestor, ownership: "borrowed" });
+    }
+    if (isClassOrInterface(type)) {
+        return classSelfDescriptor(context, type);
     }
     if (type.kind === "record") {
         return recordExpression(context, type, transferOwnership(instance.transferOwnership));
     }
     return tObject("borrowed");
 };
+// A record expresses its acquire/release pair as `copy-function`/`free-function`: no `<record>` in
+// any installed GIR carries `glib:ref-func`, and GVariant's copy function really is
+// `g_variant_ref_sink`.
 const recordRefPair = (record) => ({
     refFunc: record.glibRefFunc ?? record.copyFunc,
     unrefFunc: record.glibUnrefFunc ?? record.freeFunc,
 });
-const recordNeedsFallbackClass = (record) => {
+const requiresFallbackClass = (record) => {
     const { refFunc, unrefFunc } = recordRefPair(record);
-    if (refFunc !== undefined && unrefFunc !== undefined)
+    if (refFunc !== undefined && unrefFunc !== undefined) {
         return record.glibTypeName === undefined;
+    }
     return record.glibGetType === undefined;
 };
-const structExpression = (context, resolved, ownership, callerAllocated) => {
+const structExpression = (context, resolved, ownership, options) => {
     const { size } = computeRecordFieldSlots(context, resolved.value.fields, resolved.value.isUnion);
     const wrapperClass = context.qualify(resolved.namespace.name, resolved.value.name);
+    const isCopyable = isValueMarshalable(context, resolved.namespace.name, resolved.value);
     return tStruct(ownership, {
-        size: size > 0 ? size : undefined,
+        size: isCopyable && size > 0 ? size : undefined,
         wrapperClass,
+        callerAllocated: options.callerAllocated,
+        inline: options.inline,
+    });
+};
+const fundamentalRecordExpression = (options) => {
+    const { resolved, refFunc, unrefFunc, ownership, wrapperClass, inline } = options;
+    return renderFundamental({
+        lib: resolved.namespace.sharedLibrary ?? "",
+        refFunc,
+        unrefFunc,
+        typeName: resolved.value.glibTypeName,
+        ownership,
+        wrapperClass,
+        inline,
+    });
+};
+const boxedRecordExpression = (options) => {
+    const { context, resolved, ownership, callerAllocated, inline, typeFnName } = options;
+    const record = resolved.value;
+    const glibName = record.glibTypeName ?? record.cType ?? record.name;
+    const { size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+    return tBoxed(glibName, {
+        ownership,
+        sharedLibrary: resolved.namespace.sharedLibrary,
+        getTypeFnName: typeFnName,
         callerAllocated,
+        inline,
+        size: size > 0 ? size : undefined,
     });
 };
-const recordExpression = (context, resolved, ownership, callerAllocated = false) => {
+const plainRecordExpression = (context, resolved, ownership, placement) => {
+    const record = resolved.value;
+    const layout = {
+        callerAllocated: placement.isCallerAllocated ?? false,
+        inline: placement.isInline ?? false,
+    };
+    if (record.glibGetType === undefined) {
+        return structExpression(context, resolved, ownership, layout);
+    }
+    return boxedRecordExpression({ context, resolved, ownership, ...layout, typeFnName: record.glibGetType });
+};
+const recordExpression = (context, resolved, ownership, placement = {}) => {
     const record = resolved.value;
     const { refFunc, unrefFunc } = recordRefPair(record);
-    const wrapperClass = recordNeedsFallbackClass(record)
-        ? context.qualify(resolved.namespace.name, record.name)
-        : undefined;
     if (refFunc !== undefined && unrefFunc !== undefined) {
-        const lib = resolved.namespace.sharedLibrary ?? "";
-        return renderFundamental({
-            lib,
+        const wrapperClass = requiresFallbackClass(record)
+            ? context.qualify(resolved.namespace.name, record.name)
+            : undefined;
+        return fundamentalRecordExpression({
+            resolved,
             refFunc,
             unrefFunc,
-            typeName: record.glibTypeName,
             ownership,
             wrapperClass,
+            inline: placement.isInline ?? false,
         });
     }
-    if (record.glibGetType === undefined) {
-        return structExpression(context, resolved, ownership, callerAllocated);
+    return plainRecordExpression(context, resolved, ownership, placement);
+};
+const rawEnumDescriptor = (isSigned) => (isSigned ? tInt32 : tUint32);
+const enumExpression = (resolved) => {
+    const getter = resolved.value.glibGetType;
+    const isSigned = resolved.value.members.some((member) => member.value.startsWith("-"));
+    if (getter === undefined || getter === "") {
+        return rawEnumDescriptor(isSigned);
     }
-    const glibName = record.glibTypeName ?? record.cType ?? record.name;
-    const { size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
-    return tBoxed(glibName, {
-        ownership,
-        sharedLibrary: resolved.namespace.sharedLibrary,
-        getTypeFnName: record.glibGetType,
-        callerAllocated,
-        size: size > 0 ? size : undefined,
-    });
+    const lib = resolved.namespace.sharedLibrary ?? "";
+    return resolved.value.kind === "bitfield" ? tFlags(lib, getter, isSigned) : tEnum(lib, getter, isSigned);
 };
 const expressionForResolved = (context, resolved, transfer, options) => {
     const ownership = transferOwnership(transfer);
     switch (resolved.kind) {
         case "class":
-        case "interface":
-            return classOrInterfaceExpression(resolved, ownership);
-        case "record":
-            return recordExpression(context, resolved, ownership, options.callerAllocated ?? false);
+        case "interface": {
+            return classOrInterfaceExpression(context, resolved, ownership, options.isNewlyCreated ?? false);
+        }
+        case "record": {
+            return recordExpression(context, resolved, ownership, {
+                isCallerAllocated: options.callerAllocated ?? false,
+                isInline: options.isInline ?? false,
+            });
+        }
         case "enum": {
-            const getter = resolved.value.glibGetType;
-            const signed = resolved.value.members.some((member) => member.value.startsWith("-"));
-            if (getter === undefined || getter === "")
-                return signed ? tInt32 : tUint32;
-            const lib = resolved.namespace.sharedLibrary ?? "";
-            return resolved.value.kind === "bitfield" ? tFlags(lib, getter, signed) : tEnum(lib, getter, signed);
+            return enumExpression(resolved);
         }
-        case "alias":
+        case "alias": {
             return aliasExpression(context, resolved.value.target, transfer, options);
+        }
     }
 };
-const arrayExpression = (context, ref, transfer, argIndexOffset) => {
+const arrayExpression = (context, ref, transfer, options) => {
+    if (hasUnknownArrayLength(ref)) {
+        return tUint64;
+    }
     const ownership = transferOwnership(transfer);
-    const element = renderDescriptor(context, ref.element, deriveElementTransfer(transfer), { argIndexOffset });
+    const element = renderDescriptor(context, ref.element, deriveElementTransfer(transfer), options);
     const size = inlineElementSize(context, ref.element, ref.elementCType);
     if (ref.lengthParameterIndex !== undefined) {
-        return tSizedArray(element, ref.lengthParameterIndex + argIndexOffset, ownership, size);
+        return tSizedArray(element, mapArgIndex(options, ref.lengthParameterIndex), ownership, size);
     }
     if (ref.fixedSize !== undefined) {
         return tFixedArray(element, ref.fixedSize, ownership, size);
     }
     return tArray(element, ownership, size);
 };
-const inlineElementSize = (context, element, elementCType) => {
-    if (element === undefined)
+const recordInlineSize = (context, record) => {
+    if (record.opaque || record.disguised || record.fields.length === 0) {
         return undefined;
-    if (elementCType?.includes("*"))
+    }
+    const { size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+    return size > 0 ? size : undefined;
+};
+const inlineElementSize = (context, element, elementCType) => {
+    if (element === undefined) {
         return undefined;
-    const type = context.library.typeOf(element);
-    if (type?.kind !== "record")
+    }
+    if (elementCType?.includes("*")) {
         return undefined;
-    const record = type.value;
-    if (record.opaque || record.disguised || record.fields.length === 0)
+    }
+    const type = context.library.typeFor(element);
+    if (type?.kind !== "record") {
         return undefined;
-    const { size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
-    return size > 0 ? size : undefined;
+    }
+    return recordInlineSize(context, type.value);
 };
 const aliasExpression = (context, target, transfer, options) => {
     if (target === undefined) {
@@ -294,4 +437,5 @@ const aliasExpression = (context, target, transfer, options) => {
     }
     return renderDescriptor(context, target, transfer, options);
 };
+export { isInlineCallbackRef, shouldOmitPrimaryReturn, renderDescriptor, isScalarRef, isCellInout, renderParamDescriptor, renderCallbackType, renderSelfDescriptor, };
 //# sourceMappingURL=descriptor-render.js.map