@gtkx/codegen 0.21.0 → 1.0.0-rc.1

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

@@ -0,0 +1,194 @@
+import { sourceStringLiteral, toCamelCase, toCamelIdentifier } from "@gtkx/utils";
+import { renderDescriptor } from "../../analysis/descriptor-render.js";
+import { inputParameters } from "../../analysis/param-structure.js";
+import { renderTsType } from "../../analysis/ts-type.js";
+import type { GirFunction } from "../../gir/function.js";
+import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { renderBlock } from "../../writer/emit.js";
+import { isEmittableCallable } from "./callables.js";
+import { methodExportName, renderMethodReturnType } from "./method.js";
+
+const isNullablePropertyType = (context: ModuleContext, type: TypeId | undefined): boolean => {
+    if (type === undefined) return false;
+    const resolved = context.library.typeOf(type);
+    if (resolved === undefined) return true;
+    if (resolved.kind === "primitive") return false;
+    if (resolved.kind === "enum") return false;
+    if (resolved.kind === "alias") return isNullablePropertyType(context, resolved.value.target);
+    return true;
+};
+
+export type ResolvedAccessor = {
+    jsName: string;
+    tsType: string;
+    hasGetter: boolean;
+    writable: boolean;
+    getterMember: string | undefined;
+    getMethod: GirFunction | undefined;
+    setterMember: string | undefined;
+};
+
+export type PropertyAccessorArgs = {
+    context: ModuleContext;
+    property: GirProperty;
+    claimedNames: Set<string>;
+    methodByName: Map<string, GirFunction>;
+    inheritedType?: string | undefined;
+};
+
+type AccessorDelegate = { member: string | undefined; method: GirFunction | undefined };
+
+const resolveGetterDelegate = (args: PropertyAccessorArgs, jsName: string): AccessorDelegate => {
+    const { context, property, claimedNames, methodByName } = args;
+    const member = delegateMember(property.getter, jsName, claimedNames);
+    const method =
+        member !== undefined && property.getter !== undefined ? methodByName.get(property.getter) : undefined;
+    const delegatable =
+        method === undefined ||
+        (inputParameters(context.library, method).length === 0 &&
+            !renderMethodReturnType(context, method).startsWith("["));
+    return delegatable ? { member, method } : { member: undefined, method: undefined };
+};
+
+const resolveSetterDelegate = (args: PropertyAccessorArgs, jsName: string, writable: boolean): AccessorDelegate => {
+    const { context, property, claimedNames, methodByName } = args;
+    const member = writable ? delegateMember(property.setter, jsName, claimedNames) : undefined;
+    const method =
+        member !== undefined && property.setter !== undefined ? methodByName.get(property.setter) : undefined;
+    const delegatable = method === undefined || inputParameters(context.library, method).length === 1;
+    return delegatable ? { member, method } : { member: undefined, method: undefined };
+};
+
+export const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefined => {
+    const { context, property, claimedNames } = args;
+    const jsName = toCamelIdentifier(property.name);
+    if (claimedNames.has(jsName)) return undefined;
+    if (jsName === "constructor") return undefined;
+
+    const writable = isConstructableProperty(property);
+    const { member: getterMember, method: getMethod } = resolveGetterDelegate(args, jsName);
+    const { member: setterMember, method: setMethod } = resolveSetterDelegate(args, jsName, writable);
+    const setParam = setMethod?.parameters[0];
+
+    const hasGetter = property.readable || getterMember !== undefined;
+    if (!hasGetter && !writable) return undefined;
+
+    const ownType =
+        setParam !== undefined
+            ? renderTsType(context, setParam.type, setParam.nullable || setParam.optional)
+            : getMethod !== undefined
+              ? renderMethodReturnType(context, getMethod)
+              : renderTsType(context, property.type, isNullablePropertyType(context, property.type));
+
+    const tsType = args.inheritedType !== undefined && args.inheritedType !== ownType ? args.inheritedType : ownType;
+
+    return { jsName, tsType, hasGetter, writable, getterMember, getMethod, setterMember };
+};
+
+export const resolveOwnerAccessor = (
+    context: ModuleContext,
+    property: GirProperty,
+    methods: GirFunction[],
+): ResolvedAccessor | undefined => {
+    const methodByName = new Map<string, GirFunction>();
+    const claimedNames = new Set<string>();
+    for (const method of methods) {
+        if (!isEmittableCallable(context, method)) continue;
+        methodByName.set(method.name, method);
+        claimedNames.add(methodExportName(method));
+    }
+    return resolveAccessor({ context, property, claimedNames, methodByName });
+};
+
+export const resolveAccessorType = (
+    context: ModuleContext,
+    property: GirProperty,
+    methods: GirFunction[],
+): string | undefined => resolveOwnerAccessor(context, property, methods)?.tsType;
+
+const withAccessor = (
+    args: PropertyAccessorArgs,
+    render: (accessor: ResolvedAccessor) => string,
+): string | undefined => {
+    const accessor = resolveAccessor(args);
+    if (accessor === undefined) return undefined;
+    return render(accessor);
+};
+
+export const renderResolvedPropertyAccessor = (
+    context: ModuleContext,
+    property: GirProperty,
+    accessor: ResolvedAccessor,
+): string => {
+    const { jsName, tsType, hasGetter, writable, getterMember, getMethod, setterMember } = accessor;
+
+    const blocks: string[] = [];
+    if (hasGetter) {
+        const getBody = renderGetterBody({ context, property, getterMember, getMethod, tsType });
+        blocks.push(renderBlock(`get ${jsName}(): ${tsType}`, getBody));
+    }
+
+    if (writable) {
+        const setBody =
+            setterMember !== undefined ? `this.${setterMember}(value);` : renderGenericSetBody(context, property);
+        blocks.push(renderBlock(`set ${jsName}(value: ${tsType})`, setBody));
+    }
+    return `${renderJsDoc(property.doc)}${blocks.join("\n\n")}`;
+};
+
+export const renderPropertyAccessor = (args: PropertyAccessorArgs): string | undefined =>
+    withAccessor(args, (accessor) => renderResolvedPropertyAccessor(args.context, args.property, accessor));
+
+export const renderPropertyAccessorSignature = (args: PropertyAccessorArgs): string | undefined =>
+    withAccessor(args, ({ jsName, tsType, hasGetter, writable }) => {
+        const doc = renderJsDoc(args.property.doc);
+        if (hasGetter && writable) return `${doc}${jsName}: ${tsType};`;
+        if (hasGetter) return `${doc}get ${jsName}(): ${tsType};`;
+        return `${doc}set ${jsName}(value: ${tsType});`;
+    });
+
+const renderPropertyDescriptor = (context: ModuleContext, property: GirProperty): string =>
+    renderDescriptor(context, property.type, property.transferOwnership);
+
+const renderGenericGetBody = (context: ModuleContext, property: GirProperty, tsType: string): string => {
+    context.addRuntimeImport("getObjectProperty");
+    context.addRuntimeImport("t");
+    return `return getObjectProperty(this, ${sourceStringLiteral(property.name)}, ${renderPropertyDescriptor(context, property)}) as ${tsType};`;
+};
+
+const renderGenericSetBody = (context: ModuleContext, property: GirProperty): string => {
+    context.addRuntimeImport("setObjectProperty");
+    context.addRuntimeImport("t");
+    return `setObjectProperty(this, ${sourceStringLiteral(property.name)}, ${renderPropertyDescriptor(context, property)}, value);`;
+};
+
+type GetterBodyOptions = {
+    context: ModuleContext;
+    property: GirProperty;
+    getterMember: string | undefined;
+    getMethod: GirFunction | undefined;
+    tsType: string;
+};
+
+const renderGetterBody = (options: GetterBodyOptions): string => {
+    const { context, property, getterMember, getMethod, tsType } = options;
+    if (getterMember === undefined) return renderGenericGetBody(context, property, tsType);
+    if (getMethod === undefined) return `return this.${getterMember}() as ${tsType};`;
+    const getType = renderMethodReturnType(context, getMethod);
+    return getType === tsType ? `return this.${getterMember}();` : `return this.${getterMember}() as ${tsType};`;
+};
+
+const delegateMember = (
+    attribute: string | undefined,
+    accessorName: string,
+    claimedNames: Set<string>,
+): string | undefined => {
+    if (attribute === undefined) return undefined;
+    const member = toCamelCase(attribute);
+    if (member === accessorName) return undefined;
+    if (!claimedNames.has(member)) return undefined;
+    return member;
+};

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

@@ -0,0 +1,87 @@
+import { sourceStringLiteral, toCamelIdentifier } from "@gtkx/utils";
+import { renderDescriptor } from "../../analysis/descriptor-render.js";
+import { renderTsType } from "../../analysis/ts-type.js";
+import type { GirField } from "../../gir/field.js";
+import type { GirRecord } from "../../gir/record.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
+import { emitFieldWrite, isEmittableField } from "./record-field-accessor.js";
+import { computeRecordFieldSlots, type RecordFieldSlot } from "./record-layout.js";
+
+type WritableFieldSlot = RecordFieldSlot & { field: GirField & { type: TypeId } };
+
+const isWritableFieldSlot = (context: ModuleContext, entry: RecordFieldSlot): entry is WritableFieldSlot =>
+    entry.field.writable && isEmittableField(context, entry.field);
+
+const isOpaque = (record: GirRecord): boolean => record.glibGetType === undefined && record.disguised;
+
+export const renderRecordConstructorPropsInterface = (
+    context: ModuleContext,
+    record: GirRecord,
+    className: string,
+): string => {
+    const head = `export interface ${className}ConstructorProps`;
+    if (isOpaque(record)) return renderBracedOrEmpty(head, "");
+    const { slots } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+    const lines = slots
+        .filter((entry): entry is WritableFieldSlot => isWritableFieldSlot(context, entry))
+        .map((entry) => `${toCamelIdentifier(entry.field.name)}?: ${renderTsType(context, entry.field.type, true)};`);
+    return renderBracedOrEmpty(head, lines.join("\n"));
+};
+
+export const renderRecordConstructor = (
+    context: ModuleContext,
+    record: GirRecord,
+    className: string,
+    extendsError = false,
+): string => {
+    const superCall = extendsError ? ["super();"] : [];
+    if (isOpaque(record)) {
+        return renderBlock(
+            `constructor()`,
+            [
+                ...superCall,
+                `throw new globalThis.Error(${sourceStringLiteral(`Cannot construct ${className}: opaque boxed type with no known layout`)});`,
+            ].join("\n"),
+        );
+    }
+    const { slots, size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+    if (size === 0) {
+        return extendsError
+            ? renderBlock(`constructor(props: ${className}ConstructorProps = {})`, "super();")
+            : `constructor(props: ${className}ConstructorProps = {}) {}`;
+    }
+    context.addRuntimeImport("alloc");
+    context.addRuntimeImport("setHandle");
+    const statements = [...superCall, `const handle = alloc(${allocArgs(record, size).join(", ")});`];
+    for (const entry of slots) {
+        if (!isWritableFieldSlot(context, entry)) continue;
+        statements.push(renderFieldWrite(context, entry));
+    }
+    statements.push("setHandle(this, handle);");
+    const body = statements.join("\n");
+    return renderBlock(`constructor(props: ${className}ConstructorProps = {})`, body);
+};
+
+const allocArgs = (record: GirRecord, size: number): string[] => {
+    const glibTypeName = record.glibTypeName ?? record.cType;
+    const args = [String(size)];
+    if (glibTypeName !== undefined) {
+        args.push(sourceStringLiteral(glibTypeName));
+    }
+    return args;
+};
+
+const renderFieldWrite = (context: ModuleContext, entry: WritableFieldSlot): string => {
+    context.addRuntimeImport("t");
+    const descriptor = context.hoistDescriptor(renderDescriptor(context, entry.field.type, "none"));
+    const name = toCamelIdentifier(entry.field.name);
+    const write = emitFieldWrite(context, {
+        descriptor,
+        slot: entry.slot,
+        targetExpr: "handle",
+        valueExpr: `props.${name}`,
+    });
+    return `if (props.${name} !== undefined) ${write}`;
+};

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

@@ -0,0 +1,394 @@
+import { toCamelIdentifier } from "@gtkx/utils";
+import { tStruct } from "../../analysis/descriptor.js";
+import { isInlineCallbackRef, renderDescriptor } from "../../analysis/descriptor-render.js";
+import { renderTsType } from "../../analysis/ts-type.js";
+import type { GirField } from "../../gir/field.js";
+import type { FieldSlot } from "../../gir/size.js";
+import type { GirType } from "../../gir/type.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { ModuleContext } from "../../writer/context.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { indent, renderBlock } from "../../writer/emit.js";
+import { refIsClassStruct } from "./class-struct-record.js";
+import { bitMask, computeRecordFieldSlots, mergeBitfield, type RecordFieldSlot } from "./record-layout.js";
+import { wrapReturnValue } from "./return-wrap.js";
+
+export const isEmittableField = (context: ModuleContext, field: GirField): field is GirField & { type: TypeId } =>
+    !field.private &&
+    field.type !== undefined &&
+    !isInlineCallbackRef(context.library, field.type) &&
+    !refIsClassStruct(context, field.type);
+
+type FieldWriteSpec = {
+    descriptor: string;
+    slot: FieldSlot;
+    targetExpr: string;
+    valueExpr: string;
+};
+
+export const emitFieldWrite = (context: ModuleContext, spec: FieldWriteSpec): string => {
+    const { descriptor, slot, targetExpr, valueExpr } = spec;
+    context.addRuntimeImport("write");
+    if (slot.bitWidth === undefined) {
+        return `write(${targetExpr}, ${descriptor}, ${slot.byteOffset}, ${valueExpr});`;
+    }
+    context.addRuntimeImport("read");
+    const merged = mergeBitfield(
+        `(read(${targetExpr}, ${descriptor}, ${slot.byteOffset}) as number)`,
+        valueExpr,
+        bitMask(slot.bitWidth),
+        slot.bitOffset ?? 0,
+    );
+    return `write(${targetExpr}, ${descriptor}, ${slot.byteOffset}, ${merged});`;
+};
+
+type AdmittedField = {
+    field: GirField & { type: TypeId };
+    jsName: string;
+};
+
+const admitField = (
+    context: ModuleContext,
+    slot: RecordFieldSlot,
+    claimedNames: Set<string>,
+): AdmittedField | undefined => {
+    const { field } = slot;
+    if (!field.readable && !field.writable) return undefined;
+    if (!isEmittableField(context, field)) return undefined;
+    const jsName = toCamelIdentifier(field.name);
+    if (claimedNames.has(jsName)) return undefined;
+    if (jsName === "constructor") return undefined;
+    return { field, jsName };
+};
+
+export type RecordFieldEntry = {
+    jsName: string;
+    tsType: string;
+    writable: boolean;
+    doc: string | undefined;
+};
+
+export const resolveRecordFieldEntry = (
+    context: ModuleContext,
+    slot: RecordFieldSlot,
+    claimedNames: Set<string>,
+): RecordFieldEntry | undefined => {
+    const admitted = admitField(context, slot, claimedNames);
+    if (admitted === undefined) return undefined;
+    return {
+        jsName: admitted.jsName,
+        tsType: renderTsType(context, admitted.field.type, false),
+        writable: admitted.field.writable,
+        doc: admitted.field.doc,
+    };
+};
+
+export const renderRecordFieldAccessor = (
+    context: ModuleContext,
+    slot: RecordFieldSlot,
+    claimedNames: Set<string>,
+    siblingFields: GirField[],
+): string | undefined => {
+    const admitted = admitField(context, slot, claimedNames);
+    if (admitted === undefined) return undefined;
+    const { field, jsName } = admitted;
+    const doc = renderJsDoc(field.doc);
+
+    const structArray = renderStructArrayAccessor(context, { field, jsName, slot: slot.slot, siblingFields });
+    if (structArray !== undefined) return `${doc}${structArray}`;
+
+    if (!isAccessorEligibleType(context, field.type)) {
+        const tsType = renderTsType(context, field.type, false);
+        return `${doc}declare ${jsName}: ${tsType};`;
+    }
+
+    const descriptor = context.hoistDescriptor(renderDescriptor(context, field.type, "none"));
+    const tsType = renderTsType(context, field.type, false);
+    const accessorOptions: AccessorOptions = {
+        context,
+        jsName,
+        tsType,
+        descriptor,
+        slot: slot.slot,
+        fieldType: field.type,
+    };
+    const blocks: string[] = [getterBlock(accessorOptions)];
+    if (field.writable) {
+        blocks.push(setterBlock(accessorOptions));
+    }
+    return `${doc}${blocks.join("\n\n")}`;
+};
+
+const isAccessorEligibleType = (context: ModuleContext, ref: TypeId): boolean => {
+    const type = context.library.typeOf(ref);
+    if (type === undefined) return true;
+    switch (type.kind) {
+        case "primitive":
+            return type.category !== "void" && type.category !== "unichar";
+        case "class":
+        case "interface":
+        case "record":
+        case "enum":
+        case "alias":
+            return true;
+        case "callback":
+            return context.library.nameOf(ref) !== undefined;
+        case "carray":
+            return type.fixedSize !== undefined;
+        case "list":
+        case "hashtable":
+        case "varargs":
+            return false;
+    }
+};
+
+const resolveInlineStructFields = (
+    context: ModuleContext,
+    ref: TypeId | undefined,
+    occurrenceCType: string | undefined,
+): GirField[] | undefined => {
+    if (ref === undefined) return undefined;
+    if (occurrenceCType?.endsWith("*") === true) return undefined;
+    const type = context.library.typeOf(ref);
+    if (type?.kind !== "record") return undefined;
+    if (type.value.cType?.endsWith("*") === true) return undefined;
+    if (type.value.fields.length === 0) return undefined;
+    return type.value.fields;
+};
+
+const arrayLengthExpression = (
+    arrayRef: Extract<GirType, { kind: "carray" }>,
+    siblingFields: GirField[],
+): string | undefined => {
+    if (arrayRef.fixedSize !== undefined) return String(arrayRef.fixedSize);
+    if (arrayRef.lengthParameterIndex === undefined) return undefined;
+    const lengthField = siblingFields.filter((field) => !field.private)[arrayRef.lengthParameterIndex];
+    if (lengthField === undefined) return undefined;
+    return `this.${toCamelIdentifier(lengthField.name)}`;
+};
+
+type InlineFieldVisit = {
+    jsName: string;
+    descriptor: string;
+    offset: number;
+    slot: FieldSlot;
+    type: TypeId;
+};
+
+type InlineFieldVisitors = {
+    leaf: (visit: InlineFieldVisit) => void;
+    nested: (jsName: string, nested: GirField[], offset: number) => void;
+};
+
+const visitInlineStructFields = (
+    context: ModuleContext,
+    fields: GirField[],
+    baseOffset: number,
+    visitors: InlineFieldVisitors,
+): void => {
+    const { slots } = computeRecordFieldSlots(context, fields);
+    for (const { field, slot } of slots) {
+        if (field.private || field.type === undefined || isInlineCallbackRef(context.library, field.type)) {
+            continue;
+        }
+        const jsName = toCamelIdentifier(field.name);
+        const offset = baseOffset + slot.byteOffset;
+        const nested = resolveInlineStructFields(context, field.type, field.cType);
+        if (nested !== undefined) {
+            visitors.nested(jsName, nested, offset);
+            continue;
+        }
+        if (!isAccessorEligibleType(context, field.type)) continue;
+        const descriptor = context.hoistDescriptor(renderDescriptor(context, field.type, "none"));
+        visitors.leaf({ jsName, descriptor, offset, slot, type: field.type });
+    }
+};
+
+const renderElementReadObject = (context: ModuleContext, fields: GirField[], baseOffset: number): string => {
+    const entries: string[] = [];
+    visitInlineStructFields(context, fields, baseOffset, {
+        leaf: ({ jsName, descriptor, offset, slot, type }) => {
+            if (slot.bitWidth === undefined) {
+                entries.push(
+                    `${jsName}: read(__array, ${descriptor}, __base + ${offset}) as ${renderTsType(context, type, false)}`,
+                );
+                return;
+            }
+            const shift = slot.bitOffset ?? 0;
+            entries.push(
+                `${jsName}: (((read(__array, ${descriptor}, __base + ${offset}) as number) >>> ${shift}) & ${bitMask(slot.bitWidth)})`,
+            );
+        },
+        nested: (jsName, nested, offset) => {
+            entries.push(`${jsName}: ${renderElementReadObject(context, nested, offset)}`);
+        },
+    });
+    return `{ ${entries.join(", ")} }`;
+};
+
+type ElementWriteOptions = {
+    fields: GirField[];
+    baseOffset: number;
+    valuePath: string;
+    out: string[];
+};
+
+const appendElementWriteStatements = (context: ModuleContext, options: ElementWriteOptions): void => {
+    const { fields, baseOffset, valuePath, out } = options;
+    visitInlineStructFields(context, fields, baseOffset, {
+        leaf: ({ jsName, descriptor, offset, slot }) => {
+            const valueExpr = `${valuePath}.${jsName}`;
+            if (slot.bitWidth === undefined) {
+                out.push(`write(__array, ${descriptor}, __base + ${offset}, ${valueExpr});`);
+                return;
+            }
+            const mask = bitMask(slot.bitWidth);
+            const shift = slot.bitOffset ?? 0;
+            const merged = mergeBitfield(
+                `(read(__array, ${descriptor}, __base + ${offset}) as number)`,
+                valueExpr,
+                mask,
+                shift,
+            );
+            out.push(`write(__array, ${descriptor}, __base + ${offset}, ${merged});`);
+        },
+        nested: (jsName, nested, offset) => {
+            appendElementWriteStatements(context, {
+                fields: nested,
+                baseOffset: offset,
+                valuePath: `${valuePath}.${jsName}`,
+                out,
+            });
+        },
+    });
+};
+
+type StructArrayTarget = {
+    field: GirField;
+    jsName: string;
+    slot: FieldSlot;
+    siblingFields: GirField[];
+};
+
+type StructArrayAccessorOptions = {
+    context: ModuleContext;
+    jsName: string;
+    tsType: string;
+    elementDescriptor: string;
+    offset: number;
+    lengthExpr: string;
+    elementSize: number;
+    elementFields: GirField[];
+};
+
+const structArrayGetterBlock = (options: StructArrayAccessorOptions): string => {
+    const { context, jsName, tsType, elementDescriptor, offset, lengthExpr, elementSize, elementFields } = options;
+    const element = renderElementReadObject(context, elementFields, 0);
+    const loop = [`const __base = __index * ${elementSize};`, `__result.push(${element});`].join("\n");
+    const body = [
+        `const __array = read(getHandle(this), ${elementDescriptor}, ${offset}) as ReturnType<typeof getHandle>;`,
+        `const __result: ${tsType} = [];`,
+        `for (let __index = 0; __index < ${lengthExpr}; __index++) {`,
+        indent(loop, 1),
+        "}",
+        "return __result;",
+    ].join("\n");
+    return renderBlock(`get ${jsName}(): ${tsType}`, body);
+};
+
+const structArraySetterBlock = (options: StructArrayAccessorOptions): string => {
+    const { context, jsName, tsType, elementDescriptor, offset, elementSize, elementFields } = options;
+    const writes: string[] = [];
+    appendElementWriteStatements(context, {
+        fields: elementFields,
+        baseOffset: 0,
+        valuePath: "__element",
+        out: writes,
+    });
+    const loop = [`const __base = __index * ${elementSize};`, ...writes].join("\n");
+    const body = [
+        `const __descriptor = ${elementDescriptor};`,
+        `const __array = read(getHandle(this), __descriptor, ${offset}) as ReturnType<typeof getHandle>;`,
+        `for (const [__index, __element] of __value.entries()) {`,
+        indent(loop, 1),
+        "}",
+        `write(getHandle(this), __descriptor, ${offset}, __array);`,
+    ].join("\n");
+    return renderBlock(`set ${jsName}(__value: ${tsType})`, body);
+};
+
+const renderStructArrayAccessor = (context: ModuleContext, target: StructArrayTarget): string | undefined => {
+    const { field, jsName, slot, siblingFields } = target;
+    if (field.type === undefined || slot.bitWidth !== undefined) return undefined;
+    const arrayType = context.library.typeOf(field.type);
+    if (arrayType?.kind !== "carray") return undefined;
+    const elementType = context.library.typeOf(arrayType.element);
+    if (elementType?.kind === "record" && elementType.value.glibGetType !== undefined) return undefined;
+    const elementFields = resolveInlineStructFields(context, arrayType.element, arrayType.elementCType);
+    if (elementFields === undefined) return undefined;
+    const lengthExpr = arrayLengthExpression(arrayType, siblingFields);
+    if (lengthExpr === undefined) return undefined;
+    const elementSize = computeRecordFieldSlots(context, elementFields).size;
+    if (elementSize === 0) return undefined;
+
+    context.addRuntimeImport("read");
+    context.addRuntimeImport("getHandle");
+    context.addRuntimeImport("t");
+    const options: StructArrayAccessorOptions = {
+        context,
+        jsName,
+        tsType: renderTsType(context, field.type, false),
+        elementDescriptor: tStruct("borrowed", {
+            size: `${lengthExpr} * ${elementSize}`,
+            wrapperClass: undefined,
+            callerAllocated: false,
+        }),
+        offset: slot.byteOffset,
+        lengthExpr,
+        elementSize,
+        elementFields,
+    };
+    const blocks: string[] = [];
+    if (field.readable) blocks.push(structArrayGetterBlock(options));
+    if (field.writable) {
+        context.addRuntimeImport("write");
+        blocks.push(structArraySetterBlock(options));
+    }
+    return blocks.length === 0 ? undefined : blocks.join("\n\n");
+};
+
+type AccessorOptions = {
+    context: ModuleContext;
+    jsName: string;
+    tsType: string;
+    descriptor: string;
+    slot: FieldSlot;
+    fieldType: TypeId;
+};
+
+const getterBlock = (options: AccessorOptions): string => {
+    const { context, jsName, tsType, descriptor, slot, fieldType } = options;
+    context.addRuntimeImport("read");
+    context.addRuntimeImport("getHandle");
+    if (slot.bitWidth === undefined) {
+        const valueExpression = `read(getHandle(this), ${descriptor}, ${slot.byteOffset})`;
+        const wrapped = wrapReturnValue(context, {
+            ref: fieldType,
+            nullable: false,
+            valueExpression,
+        });
+        const body = `return ${wrapped};`;
+        return renderBlock(`get ${jsName}(): ${tsType}`, body);
+    }
+    const mask = bitMask(slot.bitWidth);
+    const shift = slot.bitOffset ?? 0;
+    const body = `const __unit = read(getHandle(this), ${descriptor}, ${slot.byteOffset}) as number;\nreturn (((__unit >>> ${shift}) & ${mask}) >>> 0) as ${tsType};`;
+    return renderBlock(`get ${jsName}(): ${tsType}`, body);
+};
+
+const setterBlock = (options: AccessorOptions): string => {
+    const { context, jsName, tsType, descriptor, slot } = options;
+    context.addRuntimeImport("getHandle");
+    const body = emitFieldWrite(context, { descriptor, slot, targetExpr: "getHandle(this)", valueExpr: "value" });
+    return renderBlock(`set ${jsName}(value: ${tsType})`, body);
+};