@gtkx/codegen 1.0.0 → 1.2.0

package/src/store/gi/pipeline.ts

@@ -1,16 +1,18 @@
+import { sanitizeTypeIdentifier } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
 import type { Library } from "../../gir/library.js";
 import type { GirAlias, GirNamespace } from "../../gir/namespace.js";
 import { renderTsType } from "../../analysis/ts-type.js";
+import { getParentRef } from "../../gir/ancestry.js";
+import { isEmittableEntity } from "../../gir/emittable.js";
 import { PRIMITIVE_TS_TYPE, primitiveCategory } from "../../gir/primitives.js";
-import { splitOptionalNamespace } from "../../gir/type-ref.js";
 import { ModuleContext } from "../../writer/context.js";
 import { generateCallback } from "./callback.js";
 import { generateClass } from "./class.js";
 import { generateConstant } from "./constant.js";
 import { getDoc } from "./doc-spec.js";
 import { generateEnum } from "./enum.js";
-import { generateNamespaceBootstrap, generateNamespaceFunction } from "./function.js";
+import { generateNamespaceFunction } from "./function.js";
 import { generateInterface } from "./interface.js";
 import { generateRecord } from "./record.js";
 
@@ -28,6 +30,14 @@ const generateNamespaceModule = (namespace: GirNamespace, library: Library): str
     generateNamespaceTypes(context, namespace);
     generateNamespaceMembers(context, namespace);
 
+    if (!context.module.hasExports()) {
+        throw new Error(
+            `GIR file at ${namespace.girFile} has nothing to generate: its ${namespace.name} namespace produces a ` +
+            "module with no exports, so the file is empty, truncated, or declares only entries GIR marks as not " +
+            "introspectable",
+        );
+    }
+
     return context.module.toSource();
 };
 
@@ -58,8 +68,6 @@ const generateNamespaceMembers = (context: ModuleContext, namespace: GirNamespac
         generateNamespaceFunction(context, fn);
     }
 
-    generateNamespaceBootstrap(context, namespace);
-
     for (const constant of namespace.constants) {
         generateConstant(context, constant);
     }
@@ -70,14 +78,20 @@ const generateNamespaceMembers = (context: ModuleContext, namespace: GirNamespac
 };
 
 const generateAlias = (context: ModuleContext, alias: GirAlias): void => {
+    if (!isEmittableEntity(alias)) {
+        return;
+    }
+
     const category = alias.cType === undefined ? undefined : primitiveCategory(alias.cType);
     const targetType = category === "gtype" ? PRIMITIVE_TS_TYPE.gtype : renderTsType(context, alias.target);
     const doc = getDoc(alias);
+    const name = sanitizeTypeIdentifier(alias.name);
 
-    context.module.appendDeclaration(
-        `${doc}export type ${alias.name} = ${targetType};`,
-        context.declaredType(alias.name),
-    );
+    context.declare({
+        name,
+        code: `${doc}export type ${name} = ${targetType};`,
+        owner: alias.name,
+    });
 };
 
 const visitClass = (state: TopologicalState, klass: GirClass): void => {
@@ -124,17 +138,13 @@ const sameNamespaceParent = (
     namespaceName: string,
     byLocalName: Map<string, GirClass>,
 ): GirClass | undefined => {
-    if (klass.parent === undefined) {
-        return undefined;
-    }
-
-    const [parentNamespace, typeName] = splitOptionalNamespace(klass.parent);
+    const parent = getParentRef(klass);
 
-    if (parentNamespace !== undefined && parentNamespace !== namespaceName) {
+    if (parent === undefined || (parent.namespaceName !== undefined && parent.namespaceName !== namespaceName)) {
         return undefined;
     }
 
-    return byLocalName.get(typeName);
+    return byLocalName.get(parent.typeName);
 };
 
 export { generateNamespaceModule };

package/src/store/gi/properties.ts

@@ -1,5 +1,6 @@
 import type { GirClass } from "../../gir/class.js";
 import type { ModuleContext } from "../../writer/context.js";
+import type { Declaration } from "../../writer/module.js";
 import { collectInterfaceProperties } from "../../analysis/inheritance.js";
 import { renderBracedOrEmpty } from "../../writer/emit.js";
 import { parentCompanionRef } from "./companion.js";
@@ -8,7 +9,7 @@ import { propertyDoc, type ResolvedAccessor, resolveOwnerAccessor } from "./prop
 const PROPERTIES_SUFFIX = "Properties";
 
 const propertyEntry = (accessor: ResolvedAccessor): string =>
-    `${propertyDoc(accessor.property)}${accessor.jsName}: ${accessor.tsType};`;
+    `${propertyDoc(accessor.property)}${accessor.jsName}: ${accessor.readType};`;
 
 const interfaceEntries = (context: ModuleContext, klass: GirClass): string[] => {
     const entries: string[] = [];
@@ -31,7 +32,7 @@ const renderPropertyDeclarations = (
     klass: GirClass,
     className: string,
     accessors: ResolvedAccessor[],
-): string[] => {
+): Declaration[] => {
     const parentRef = parentCompanionRef(context, klass, PROPERTIES_SUFFIX);
     const extendsClause = parentRef === undefined ? "" : ` extends ${parentRef}`;
 
@@ -43,8 +44,11 @@ const renderPropertyDeclarations = (
     const map = `${className}${PROPERTIES_SUFFIX}`;
 
     return [
-        renderBracedOrEmpty(`export interface ${map}${extendsClause}`, entries.join("\n")),
-        renderBracedOrEmpty(`export interface ${className}`, `__properties__: ${map};`),
+        { name: map, code: renderBracedOrEmpty(`export interface ${map}${extendsClause}`, entries.join("\n")) },
+        {
+            name: className,
+            code: renderBracedOrEmpty(`export interface ${className}`, `__properties__: ${map};`),
+        },
     ];
 };
 

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

@@ -1,44 +1,38 @@
-import { camelCase, sourceStringLiteral, toCamelIdentifier } from "@gtkx/utils";
+import { sourceStringLiteral, toCamelIdentifier } from "@gtkx/utils";
 import type { GirFunction } from "../../gir/function.js";
 import type { TypeId } from "../../gir/type-id.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { renderDescriptor } from "../../analysis/descriptor-render.js";
-import { inputParameters } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
 import { renderBlock } from "../../writer/emit.js";
 import { isEmittableCallable } from "./callables.js";
 import { getDoc } from "./doc-spec.js";
-import { methodExportName, renderMethodReturnType } from "./method.js";
+import { methodExportName } from "./method.js";
+
+type InheritedAccessorTypes = {
+    readType: string | undefined;
+    writeType: string | undefined;
+};
 
 type ResolvedAccessor = {
     property: GirProperty;
     jsName: string;
-    tsType: string;
+    readType: string;
+    writeType: string;
     hasGetter: boolean;
     isWritable: boolean;
-    getterMember: string | undefined;
-    getterMethod: GirFunction | undefined;
-    setterMember: string | undefined;
 };
 
 type PropertyAccessorArgs = {
     context: ModuleContext;
     property: GirProperty;
     claimedNames: Set<string>;
-    methodByName: Map<string, GirFunction>;
-    inheritedType?: string | undefined;
+    inheritedTypes?: InheritedAccessorTypes | undefined;
+    inheritedNames?: Set<string> | undefined;
 };
 
-type AccessorDelegate = { member: string | undefined; method: GirFunction | undefined };
-
-type GetterBodyOptions = {
-    context: ModuleContext;
-    property: GirProperty;
-    getterMember: string | undefined;
-    getterMethod: GirFunction | undefined;
-    tsType: string;
-};
+const NON_NULLABLE_KINDS: Set<string> = new Set(["primitive", "enum"]);
 
 const isNullablePropertyType = (context: ModuleContext, type: TypeId | undefined): boolean => {
     if (type === undefined) {
@@ -51,105 +45,49 @@ const isNullablePropertyType = (context: ModuleContext, type: TypeId | 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;
-};
-
-const resolveDelegate = (
-    args: PropertyAccessorArgs,
-    attribute: string | undefined,
-    member: string | undefined,
-    isDelegatable: (method: GirFunction) => boolean,
-): AccessorDelegate => {
-    const method = member !== undefined && attribute !== undefined ? args.methodByName.get(attribute) : undefined;
-    const canDelegate = method === undefined || isDelegatable(method);
-
-    return canDelegate ? { member, method } : { member: undefined, method: undefined };
-};
-
-const resolveGetterDelegate = (args: PropertyAccessorArgs, jsName: string): AccessorDelegate => {
-    const { context, property, claimedNames } = args;
-    const member = delegateMember(property.getter, jsName, claimedNames);
-
-    return resolveDelegate(
-        args,
-        property.getter,
-        member,
-        (method) =>
-            inputParameters(context.library, method).length === 0 &&
-            !renderMethodReturnType(context, method).startsWith("["),
-    );
+    return !NON_NULLABLE_KINDS.has(resolved.kind);
 };
 
-const resolveSetterDelegate = (args: PropertyAccessorArgs, jsName: string, isWritable: boolean): AccessorDelegate => {
-    const { context, property, claimedNames } = args;
-    const member = isWritable ? delegateMember(property.setter, jsName, claimedNames) : undefined;
-
-    return resolveDelegate(
-        args,
-        property.setter,
-        member,
-        (method) => inputParameters(context.library, method).length === 1,
+const declaredPropertyType = (context: ModuleContext, property: GirProperty): string =>
+    renderTsType(
+        context,
+        property.type,
+        property.defaultValue === "NULL" || isNullablePropertyType(context, property.type),
     );
-};
-
-const resolveOwnType = (
-    context: ModuleContext,
-    property: GirProperty,
-    getterMethod: GirFunction | undefined,
-    setterMethod: GirFunction | undefined,
-): string => {
-    const setterParam = setterMethod?.parameters[0];
-
-    if (setterParam !== undefined) {
-        return renderTsType(context, setterParam.type, setterParam.nullable || setterParam.optional);
-    }
-
-    if (getterMethod !== undefined) {
-        return renderMethodReturnType(context, getterMethod);
-    }
-
-    return renderTsType(context, property.type, isNullablePropertyType(context, property.type));
-};
 
-const isSkippedAccessor = (property: GirProperty, jsName: string, claimedNames: Set<string>): boolean =>
-    !property.introspectable || claimedNames.has(jsName) || jsName === "constructor";
+const isSkippedAccessor = (args: PropertyAccessorArgs, jsName: string): boolean =>
+    !args.property.introspectable ||
+    args.claimedNames.has(jsName) ||
+    args.inheritedNames?.has(jsName) === true ||
+    jsName === "constructor";
 
-const resolveTsType = (inheritedType: string | undefined, ownType: string): string =>
-    inheritedType !== undefined && inheritedType !== ownType ? inheritedType : ownType;
+const isAccessorEmittable = (args: PropertyAccessorArgs, jsName: string, isWritable: boolean): boolean =>
+    !isSkippedAccessor(args, jsName) && (args.property.readable || isWritable);
 
 const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefined => {
-    const { context, property, claimedNames } = args;
+    const { property } = args;
     const jsName = toCamelIdentifier(property.name);
-
-    if (isSkippedAccessor(property, jsName, claimedNames)) {
-        return undefined;
-    }
-
     const isWritable = isConstructableProperty(property) && !property.constructOnly;
-    const { member: getterMember, method: getterMethod } = resolveGetterDelegate(args, jsName);
-    const { member: setterMember, method: setterMethod } = resolveSetterDelegate(args, jsName, isWritable);
-    const hasGetter = property.readable || getterMember !== undefined;
 
-    if (!hasGetter && !isWritable) {
+    if (!isAccessorEmittable(args, jsName, isWritable)) {
         return undefined;
     }
 
-    const ownType = resolveOwnType(context, property, getterMethod, setterMethod);
-    const tsType = resolveTsType(args.inheritedType, ownType);
+    const declared = declaredPropertyType(args.context, property);
+    const hasGetter = property.readable;
 
-    return { property, jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember };
+    return {
+        property,
+        jsName,
+        readType: args.inheritedTypes?.readType ?? declared,
+        writeType: args.inheritedTypes?.writeType ?? declared,
+        hasGetter,
+        isWritable,
+    };
 };
 
 const resolveOwnerAccessor = (
@@ -157,7 +95,6 @@ const resolveOwnerAccessor = (
     property: GirProperty,
     methods: GirFunction[],
 ): ResolvedAccessor | undefined => {
-    const methodByName: Map<string, GirFunction> = new Map();
     const claimedNames: Set<string> = new Set();
 
     for (const method of methods) {
@@ -165,18 +102,28 @@ const resolveOwnerAccessor = (
             continue;
         }
 
-        methodByName.set(method.name, method);
         claimedNames.add(methodExportName(method));
     }
 
-    return resolveAccessor({ context, property, claimedNames, methodByName });
+    return resolveAccessor({ context, property, claimedNames });
 };
 
-const resolveAccessorType = (
+const resolveAccessorTypes = (
     context: ModuleContext,
     property: GirProperty,
     methods: GirFunction[],
-): string | undefined => resolveOwnerAccessor(context, property, methods)?.tsType;
+): InheritedAccessorTypes | undefined => {
+    const accessor = resolveOwnerAccessor(context, property, methods);
+
+    if (accessor === undefined) {
+        return undefined;
+    }
+
+    return {
+        readType: accessor.hasGetter ? accessor.readType : undefined,
+        writeType: accessor.isWritable ? accessor.writeType : undefined,
+    };
+};
 
 const withAccessor = (
     args: PropertyAccessorArgs,
@@ -196,19 +143,15 @@ const renderResolvedPropertyAccessor = (
     property: GirProperty,
     accessor: ResolvedAccessor,
 ): string => {
-    const { jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember } = accessor;
+    const { jsName, readType, writeType, hasGetter, isWritable } = accessor;
     const blocks: string[] = [];
 
     if (hasGetter) {
-        const getterBody = renderGetterBody({ context, property, getterMember, getterMethod, tsType });
-        blocks.push(renderBlock(`get ${jsName}(): ${tsType}`, getterBody));
+        blocks.push(renderBlock(`get ${jsName}(): ${readType}`, renderGenericGetBody(context, property, readType)));
     }
 
     if (isWritable) {
-        const setterBody =
-            setterMember === undefined ? renderGenericSetBody(context, property) : `this.${setterMember}(value);`;
-
-        blocks.push(renderBlock(`set ${jsName}(value: ${tsType})`, setterBody));
+        blocks.push(renderBlock(`set ${jsName}(value: ${writeType})`, renderGenericSetBody(context, property)));
     }
 
     return `${propertyDoc(property)}${blocks.join("\n\n")}`;
@@ -220,20 +163,26 @@ const propertyDoc = (property: GirProperty): string =>
 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, isWritable }) => {
-        const doc = propertyDoc(args.property);
+const renderAccessorPairSignature = (accessor: ResolvedAccessor): string => {
+    const { jsName, readType, writeType, hasGetter, isWritable } = accessor;
 
-        if (hasGetter && isWritable) {
-            return `${doc}${jsName}: ${tsType};`;
-        }
+    if (!hasGetter) {
+        return `set ${jsName}(value: ${writeType});`;
+    }
 
-        if (hasGetter) {
-            return `${doc}get ${jsName}(): ${tsType};`;
-        }
+    if (!isWritable) {
+        return `get ${jsName}(): ${readType};`;
+    }
 
-        return `${doc}set ${jsName}(value: ${tsType});`;
-    });
+    if (readType === writeType) {
+        return `${jsName}: ${readType};`;
+    }
+
+    return `get ${jsName}(): ${readType};\nset ${jsName}(value: ${writeType});`;
+};
+
+const renderPropertyAccessorSignature = (args: PropertyAccessorArgs): string | undefined =>
+    withAccessor(args, (accessor) => `${propertyDoc(args.property)}${renderAccessorPairSignature(accessor)}`);
 
 const renderPropertyDescriptor = (context: ModuleContext, property: GirProperty): string =>
     renderDescriptor(context, property.type, property.transferOwnership);
@@ -254,52 +203,15 @@ const renderGenericSetBody = (context: ModuleContext, property: GirProperty): st
     return `setObjectProperty(this, ${sourceStringLiteral(property.name)}, ${descriptor}, value);`;
 };
 
-const renderGetterBody = (options: GetterBodyOptions): string => {
-    const { context, property, getterMember, getterMethod, tsType } = options;
-
-    if (getterMember === undefined) {
-        return renderGenericGetBody(context, property, tsType);
-    }
-
-    if (getterMethod === undefined) {
-        return `return this.${getterMember}() as ${tsType};`;
-    }
-
-    const getterType = renderMethodReturnType(context, getterMethod);
-
-    return getterType === 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 = camelCase(attribute);
-
-    if (member === accessorName) {
-        return undefined;
-    }
-
-    if (!claimedNames.has(member)) {
-        return undefined;
-    }
-
-    return member;
-};
-
 export {
     propertyDoc,
     resolveAccessor,
     resolveOwnerAccessor,
-    resolveAccessorType,
+    resolveAccessorTypes,
     renderResolvedPropertyAccessor,
     renderPropertyAccessor,
     renderPropertyAccessorSignature,
+    type InheritedAccessorTypes,
     type ResolvedAccessor,
     type PropertyAccessorArgs,
 };

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

@@ -1,11 +1,14 @@
 import { sourceStringLiteral, toCamelIdentifier } from "@gtkx/utils";
 import type { GirField } from "../../gir/field.js";
+import type { GirFunction } from "../../gir/function.js";
 import type { GirRecord } from "../../gir/record.js";
 import type { TypeId } from "../../gir/type-id.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { renderDescriptor } from "../../analysis/descriptor-render.js";
+import { inputParameters, parameterIdentifier } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
+import { type Callables, staticMembers } from "./callables.js";
 import { getDoc } from "./doc-spec.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { emitFieldWrite, isEmittableField, isInlineField } from "./record-field-accessor.js";
@@ -14,22 +17,22 @@ import { isConstructibleRecord } from "./value-marshalable.js";
 
 type WritableFieldSlot = RecordFieldSlot & { field: GirField & { type: TypeId } };
 
+type RecordConstructorSpec = {
+    record: GirRecord;
+    className: string;
+    callables: Callables;
+    isErrorSubclass: boolean;
+};
+
 const isWritableFieldSlot = (context: ModuleContext, entry: RecordFieldSlot): entry is WritableFieldSlot =>
     entry.field.writable && isEmittableField(context, entry.field);
 
-const isOpaque = (record: GirRecord): boolean => record.opaque || record.disguised;
-
 const renderRecordConstructorPropsInterface = (
     context: ModuleContext,
     record: GirRecord,
     className: string,
 ): string => {
     const head = `export interface ${className}ConstructorProps`;
-
-    if (isOpaque(record) || !isConstructibleRecord(context, context.namespace.name, record)) {
-        return renderBracedOrEmpty(head, "");
-    }
-
     const { slots } = computeRecordFieldSlots(context, record.fields, record.isUnion);
 
     const lines = slots
@@ -43,8 +46,41 @@ const renderRecordConstructorPropsInterface = (
     return renderBracedOrEmpty(head, lines.join("\n"));
 };
 
-const renderOpaqueConstructor = (className: string, superCall: string[]): string => {
-    const message = sourceStringLiteral(`Cannot construct ${className}: opaque boxed type with no known layout`);
+const isSelfReturning = (context: ModuleContext, record: GirRecord, callable: GirFunction): boolean => {
+    const ref = callable.returnValue.type;
+    const name = ref === undefined ? undefined : context.library.nameFor(ref);
+
+    return name?.namespaceName === context.namespace.name && name.typeName === record.name;
+};
+
+const renderStaticCall = (context: ModuleContext, callable: GirFunction, name: string): string => {
+    const args = inputParameters(context.library, callable).map(({ parameter, index }) =>
+        parameterIdentifier(parameter, index));
+
+    return `${name}(${args.join(", ")})`;
+};
+
+const constructionHint = (context: ModuleContext, spec: RecordConstructorSpec): string | undefined => {
+    const candidates = staticMembers(context, spec.callables).filter(({ callable }) =>
+        isSelfReturning(context, spec.record, callable));
+
+    const candidate = candidates.find(({ name }) => name === "new") ?? candidates[0];
+
+    return candidate === undefined ? undefined : renderStaticCall(context, candidate.callable, candidate.name);
+};
+
+const unconstructibleMessage = (context: ModuleContext, spec: RecordConstructorSpec): string => {
+    const qualified = `${context.namespace.name}.${spec.className}`;
+    const hint = constructionHint(context, spec);
+
+    return hint === undefined
+        ? `Cannot construct ${qualified} with new: its instances come from the functions that return them.`
+        : `Cannot construct ${qualified} with new: use ${qualified}.${hint} instead.`;
+};
+
+const renderUnconstructibleGuard = (context: ModuleContext, spec: RecordConstructorSpec): string => {
+    const superCall = spec.isErrorSubclass ? ["super();"] : [];
+    const message = sourceStringLiteral(unconstructibleMessage(context, spec));
 
     return renderBlock("constructor()", [...superCall, `throw new globalThis.Error(${message});`].join("\n"));
 };
@@ -66,18 +102,14 @@ const renderFieldWrites = (context: ModuleContext, slots: RecordFieldSlot[]): st
     return statements;
 };
 
-const renderRecordConstructor = (
-    context: ModuleContext,
-    record: GirRecord,
-    className: string,
-    isErrorSubclass = false,
-): string => {
-    const superCall = isErrorSubclass ? ["super();"] : [];
+const renderRecordConstructor = (context: ModuleContext, spec: RecordConstructorSpec): string => {
+    const { record, className, isErrorSubclass } = spec;
 
-    if (isOpaque(record) || !isConstructibleRecord(context, context.namespace.name, record)) {
-        return renderOpaqueConstructor(className, superCall);
+    if (!isConstructibleRecord(context, context.namespace.name, record)) {
+        return renderUnconstructibleGuard(context, spec);
     }
 
+    const superCall = isErrorSubclass ? ["super();"] : [];
     const { slots, size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
 
     if (size === 0) {
@@ -89,9 +121,9 @@ const renderRecordConstructor = (
 
     const statements = [
         ...superCall,
-        `const handle = alloc(${allocArgs(context, record, size).join(", ")});`,
+        `const __handle = alloc(${allocArgs(context, record, size).join(", ")});`,
         ...renderFieldWrites(context, slots),
-        "setHandle(this, handle);",
+        "setHandle(this, __handle);",
     ];
 
     return renderBlock(`constructor(props: ${className}ConstructorProps = {})`, statements.join("\n"));
@@ -119,7 +151,7 @@ const renderFieldWrite = (context: ModuleContext, entry: WritableFieldSlot): str
     const write = emitFieldWrite(context, {
         descriptor,
         slot: entry.slot,
-        targetExpr: "handle",
+        targetExpr: "__handle",
         valueExpr: `props.${name}`,
     });
 

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

@@ -1,6 +1,7 @@
 import { toCamelIdentifier } from "@gtkx/utils";
 import type { GirAnnotations } from "../../gir/annotations.js";
 import type { GirField } from "../../gir/field.js";
+import type { GirRecord } from "../../gir/record.js";
 import type { FieldSlot } from "../../gir/size.js";
 import type { TypeId } from "../../gir/type-id.js";
 import type { GirType } from "../../gir/type.js";
@@ -365,6 +366,21 @@ const visitInlineStructFields = (
     }
 };
 
+const inlineLeafCount = (context: ModuleContext, fields: GirField[]): number => {
+    let count = 0;
+
+    visitInlineStructFields(context, fields, 0, {
+        leaf: () => {
+            count += 1;
+        },
+        nested: (_jsName, nested) => {
+            count += inlineLeafCount(context, nested);
+        },
+    });
+
+    return count;
+};
+
 const elementAccessExpr = (descriptor: string, offset: number): string =>
     `read(__array, ${descriptor}, __base + ${String(offset)})`;
 
@@ -451,7 +467,7 @@ const structArrayGetterBlock = (options: StructArrayAccessorOptions): string =>
 };
 
 const structArraySetterStatements = (context: ModuleContext, options: StructArrayAccessorOptions): string => {
-    const { elementDescriptor, offset, elementSize, elementFields } = options;
+    const { elementDescriptor, offset, elementSize, elementFields, lengthExpr } = options;
     const writes: string[] = [];
 
     appendElementWriteStatements(context, {
@@ -467,7 +483,7 @@ const structArraySetterStatements = (context: ModuleContext, options: StructArra
         `const __descriptor = ${elementDescriptor};`,
         `const __array = read(getHandle(this), __descriptor, ${String(offset)}) as ReturnType<typeof getHandle>;`,
         "for (const [__index, __element] of __value.entries()) {",
-        indent(loop, 1),
+        indent(`if (__index >= ${lengthExpr}) {\n    break;\n}\n\n${loop}`, 1),
         "}",
         `write(getHandle(this), __descriptor, ${String(offset)}, __array);`,
     ].join("\n");
@@ -479,6 +495,12 @@ const structArraySetterBlock = (options: StructArrayAccessorOptions): string =>
         structArraySetterStatements(options.context, options),
     );
 
+const isPlainDataRecord = (record: GirRecord): boolean =>
+    record.glibGetType === undefined &&
+    record.constructors.length === 0 &&
+    record.functions.length === 0 &&
+    record.methods.length === 0;
+
 const resolveStructArrayElements = (context: ModuleContext, fieldType: TypeId): StructArrayElements | undefined => {
     const arrayType = context.library.typeFor(fieldType);
 
@@ -488,7 +510,7 @@ const resolveStructArrayElements = (context: ModuleContext, fieldType: TypeId):
 
     const elementType = context.library.typeFor(arrayType.element);
 
-    if (elementType?.kind === "record" && elementType.value.glibGetType !== undefined) {
+    if (elementType?.kind === "record" && !isPlainDataRecord(elementType.value)) {
         return undefined;
     }
 
@@ -536,7 +558,7 @@ const resolveStructArray = (context: ModuleContext, target: StructArrayTarget):
 
     const shape = resolveStructArrayShape(context, elements, siblingFields);
 
-    if (shape === undefined) {
+    if (shape === undefined || inlineLeafCount(context, elements.elementFields) === 0) {
         return undefined;
     }