@gtkx/codegen 1.1.0 → 1.2.1

package/src/store/gi/enum.ts

@@ -1,4 +1,4 @@
-import { sanitizeTypeIdentifier, sourceStringLiteral, uniqBy } from "@gtkx/utils";
+import { escapeIdentifierStart, sanitizeTypeIdentifier, sourceStringLiteral, uniqBy } from "@gtkx/utils";
 import type { EnumMember, GirEnum } from "../../gir/enum.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { hasAnnotations } from "../../gir/annotations.js";
@@ -94,11 +94,7 @@ const appendEnumDeclaration = (context: ModuleContext, enumeration: GirEnum, mem
     });
 };
 
-const enumMemberKey = (name: string): string => {
-    const upper = name.toUpperCase().replaceAll("-", "_");
-
-    return /^\d/.test(upper) ? `_${upper}` : upper;
-};
+const enumMemberKey = (name: string): string => escapeIdentifierStart(name.toUpperCase().replaceAll("-", "_"));
 
 const renderQuarkExpression = (context: ModuleContext, errorDomain: string): string => {
     if (context.namespace.name === "GLib") {

package/src/store/gi/gtype-binding.ts

@@ -1,17 +1,32 @@
 import { sourceStringLiteral } from "@gtkx/utils";
 import type { ModuleContext } from "../../writer/context.js";
 import { PRIMITIVE_TS_TYPE } from "../../gir/primitives.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { renderBlock } from "../../writer/emit.js";
 
 type TypeSource = {
     glibGetType: string | undefined;
     glibTypeName: string | undefined;
 };
 
+const GTYPE_NOTE = [
+    "The GType this class is registered under, read off the class it is accessed on rather than",
+    "inherited, so a subclass `registerClass` created reports its own type and one that never went",
+    "through `registerClass` reports the invalid type.",
+].join("\n");
+
 const gtypeTsType = (context: ModuleContext): string =>
     context.namespace.name === "GObject" ? "Type" : PRIMITIVE_TS_TYPE.gtype;
 
 const gtypeMemberDeclaration = (context: ModuleContext): string => `declare __type__: ${gtypeTsType(context)};`;
 
+const gtypeStaticMember = (context: ModuleContext): string => {
+    context.addRuntimeImport("getClassType");
+    const block = renderBlock(`static get __gtype__(): ${gtypeTsType(context)}`, "return getClassType(this);");
+
+    return `${renderJsDoc(undefined, GTYPE_NOTE)}${block}`;
+};
+
 const renderInternGtype = (context: ModuleContext, typeName: string | undefined): string | undefined => {
     if (typeName === undefined) {
         return undefined;
@@ -48,4 +63,4 @@ const renderSourceGtype = (context: ModuleContext, source: TypeSource): string |
         ? undefined
         : renderGtypeExpression(context, source.glibGetType, source.glibTypeName);
 
-export { gtypeTsType, gtypeMemberDeclaration, renderSourceGtype };
+export { gtypeTsType, gtypeMemberDeclaration, gtypeStaticMember, renderSourceGtype };

package/src/store/gi/interface.ts

@@ -21,7 +21,7 @@ import {
     renderStaticHead,
 } from "./callables.js";
 import { annotationSpec, getDoc } from "./doc-spec.js";
-import { renderSourceGtype } from "./gtype-binding.js";
+import { gtypeStaticMember, renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import {
     type PropertyAccessorArgs,
@@ -336,11 +336,11 @@ const collectMethodMembers = (options: MethodMemberOptions): string[] => {
 };
 
 const collectPropertyMembers = (options: PropertyMemberOptions): string[] => {
-    const { context, iface, scope, renderers, claimedNames } = options;
+    const { context, iface, renderers, claimedNames } = options;
     const members: string[] = [];
 
     for (const property of iface.properties) {
-        const block = renderers.renderProperty({ context, property, claimedNames, methodByName: scope.methodByName });
+        const block = renderers.renderProperty({ context, property, claimedNames });
 
         if (block !== undefined) {
             members.push(block);
@@ -378,7 +378,7 @@ const renderInterfaceClass = (context: ModuleContext, options: InterfaceClassOpt
     const members: string[] = [];
 
     if (gtypeExpr !== undefined) {
-        members.push(renderInterfaceHasInstance(context, className, gtypeExpr));
+        members.push(renderInterfaceHasInstance(context, className, gtypeExpr), gtypeStaticMember(context));
     }
 
     members.push(...renderStaticHead(context, callables, className), renderInterfaceBrand(context, implRef));

package/src/store/gi/method.ts

@@ -1,4 +1,4 @@
-import { camelCase, sourceStringLiteral } from "@gtkx/utils";
+import { camelCase, escapeIdentifierStart, sourceStringLiteral } from "@gtkx/utils";
 import type { GirFunction } from "../../gir/function.js";
 import type { GirType } from "../../gir/type.js";
 import type { ModuleContext } from "../../writer/context.js";
@@ -19,7 +19,7 @@ import {
     inputParameters,
     parameterIdentifier,
 } from "../../analysis/param-structure.js";
-import { renderTsType } from "../../analysis/ts-type.js";
+import { renderParameterTsType, renderTsType } from "../../analysis/ts-type.js";
 import { type GirParameter, isCallerAllocatedOut, isInoutParameter, isOutParameter } from "../../gir/parameter.js";
 import { hasUnknownArrayLength, type TypeId } from "../../gir/type-id.js";
 import { areClosuresInvoked } from "./closure-invocation.js";
@@ -86,12 +86,7 @@ type PlanArgsContext = {
     folded: Set<number>;
 };
 
-const memberName = (girName: string): string => {
-    const camel = camelCase(girName);
-
-    return /^\d/.test(camel) ? `_${camel}` : camel;
-};
-
+const memberName = (girName: string): string => escapeIdentifierStart(camelCase(girName));
 const methodExportName = (fn: GirFunction): string => memberName(fn.name);
 
 const arrayLengthArgument = (source: GirParameter, sourceIndex: number): string => {
@@ -125,7 +120,7 @@ const parameterAnnotation = (context: ModuleContext, fn: GirFunction, parameter:
         return comparator;
     }
 
-    const base = renderTsType(context, parameter.type, parameter.nullable);
+    const base = renderParameterTsType(context, parameter.type, parameter.nullable);
 
     return requiresClosureAnnotation(context, fn, parameter) ? closureAnnotation(context, base) : base;
 };

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

@@ -1,21 +1,14 @@
-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 { comparisonContextFor } from "../../writer/comparison-context.js";
 import { renderBlock } from "../../writer/emit.js";
 import { isEmittableCallable } from "./callables.js";
 import { getDoc } from "./doc-spec.js";
-import { methodExportName, renderMethodReturnType } from "./method.js";
-
-type AccessorTypes = {
-    readType: string;
-    writeType: string;
-};
+import { methodExportName } from "./method.js";
 
 type InheritedAccessorTypes = {
     readType: string | undefined;
@@ -29,24 +22,17 @@ type ResolvedAccessor = {
     writeType: string;
     hasGetter: boolean;
     isWritable: boolean;
-    getterMember: string | undefined;
-    setterMember: string | undefined;
 };
 
 type PropertyAccessorArgs = {
     context: ModuleContext;
     property: GirProperty;
     claimedNames: Set<string>;
-    methodByName: Map<string, GirFunction>;
     inheritedTypes?: InheritedAccessorTypes | undefined;
     inheritedNames?: Set<string> | undefined;
 };
 
-type AccessorDelegate = { member: string; method: GirFunction };
-type AccessorDelegates = { getter: AccessorDelegate | undefined; setter: AccessorDelegate | undefined };
-type TypedDelegates = { types: AccessorTypes; delegates: AccessorDelegates };
-
-const NULLABLE_SUFFIX = " | null";
+const NON_NULLABLE_KINDS: Set<string> = new Set(["primitive", "enum"]);
 
 const isNullablePropertyType = (context: ModuleContext, type: TypeId | undefined): boolean => {
     if (type === undefined) {
@@ -59,141 +45,19 @@ 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 | undefined => {
-    const method = member !== undefined && attribute !== undefined ? args.methodByName.get(attribute) : undefined;
-
-    if (member === undefined || method === undefined || !isDelegatable(method)) {
-        return undefined;
-    }
-
-    return { member, method };
-};
-
-const resolveGetterDelegate = (args: PropertyAccessorArgs, jsName: string): AccessorDelegate | undefined => {
-    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("["),
-    );
-};
-
-const resolveSetterDelegate = (
-    args: PropertyAccessorArgs,
-    jsName: string,
-    isWritable: boolean,
-): AccessorDelegate | undefined => {
-    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 baseTypeName = (type: string): string =>
-    type.endsWith(NULLABLE_SUFFIX) ? type.slice(0, -NULLABLE_SUFFIX.length) : type;
-
-const areDelegateBaseTypesAgreeing = (
-    context: ModuleContext,
-    getter: AccessorDelegate | undefined,
-    setter: AccessorDelegate | undefined,
-): boolean => {
-    const setterParam = setter?.method.parameters[0];
-
-    if (setterParam === undefined || getter === undefined) {
-        return true;
-    }
-
-    const scratch = comparisonContextFor(context);
-    const read = baseTypeName(renderMethodReturnType(scratch, getter.method));
-    const written = baseTypeName(renderTsType(scratch, setterParam.type, false));
-
-    return read === written;
-};
-
-const resolveDelegates = (args: PropertyAccessorArgs, jsName: string, isWritable: boolean): AccessorDelegates => {
-    const getter = resolveGetterDelegate(args, jsName);
-    const setter = resolveSetterDelegate(args, jsName, isWritable);
-
-    if (areDelegateBaseTypesAgreeing(args.context, getter, setter)) {
-        return { getter, setter };
-    }
-
-    return { getter, setter: undefined };
+    return !NON_NULLABLE_KINDS.has(resolved.kind);
 };
 
 const declaredPropertyType = (context: ModuleContext, property: GirProperty): string =>
-    renderTsType(context, property.type, isNullablePropertyType(context, property.type));
-
-const resolveOwnTypes = (
-    context: ModuleContext,
-    property: GirProperty,
-    delegates: AccessorDelegates,
-): AccessorTypes => {
-    const getterMethod = delegates.getter?.method;
-    const setterParam = delegates.setter?.method.parameters[0];
-
-    return {
-        readType: getterMethod === undefined
-            ? declaredPropertyType(context, property)
-            : renderMethodReturnType(context, getterMethod),
-        writeType: setterParam === undefined
-            ? declaredPropertyType(context, property)
-            : renderTsType(context, setterParam.type, setterParam.nullable || setterParam.optional),
-    };
-};
-
-const isAssignableType = (source: string, target: string): boolean =>
-    source === target || baseTypeName(target) === source;
-
-const agreeingDelegates = (
-    delegates: AccessorDelegates,
-    ownTypes: AccessorTypes,
-    declaredTypes: AccessorTypes,
-): AccessorDelegates => ({
-    getter: isAssignableType(ownTypes.readType, declaredTypes.readType) ? delegates.getter : undefined,
-    setter: isAssignableType(declaredTypes.writeType, ownTypes.writeType) ? delegates.setter : undefined,
-});
-
-const resolveTypedDelegates = (args: PropertyAccessorArgs, resolved: AccessorDelegates): TypedDelegates => {
-    const ownTypes = resolveOwnTypes(args.context, args.property, resolved);
-
-    const types = {
-        readType: args.inheritedTypes?.readType ?? ownTypes.readType,
-        writeType: args.inheritedTypes?.writeType ?? ownTypes.writeType,
-    };
-
-    return { types, delegates: agreeingDelegates(resolved, ownTypes, types) };
-};
+    renderTsType(
+        context,
+        property.type,
+        property.defaultValue === "NULL" || isNullablePropertyType(context, property.type),
+    );
 
 const isSkippedAccessor = (args: PropertyAccessorArgs, jsName: string): boolean =>
     !args.property.introspectable ||
@@ -201,31 +65,28 @@ const isSkippedAccessor = (args: PropertyAccessorArgs, jsName: string): boolean
     args.inheritedNames?.has(jsName) === true ||
     jsName === "constructor";
 
+const isAccessorEmittable = (args: PropertyAccessorArgs, jsName: string, isWritable: boolean): boolean =>
+    !isSkippedAccessor(args, jsName) && (args.property.readable || isWritable);
+
 const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefined => {
     const { property } = args;
     const jsName = toCamelIdentifier(property.name);
-
-    if (isSkippedAccessor(args, jsName)) {
-        return undefined;
-    }
-
     const isWritable = isConstructableProperty(property) && !property.constructOnly;
-    const { types, delegates } = resolveTypedDelegates(args, resolveDelegates(args, jsName, isWritable));
-    const hasGetter = property.readable || delegates.getter !== undefined;
 
-    if (!hasGetter && !isWritable) {
+    if (!isAccessorEmittable(args, jsName, isWritable)) {
         return undefined;
     }
 
+    const declared = declaredPropertyType(args.context, property);
+    const hasGetter = property.readable;
+
     return {
         property,
         jsName,
-        readType: types.readType,
-        writeType: types.writeType,
+        readType: args.inheritedTypes?.readType ?? declared,
+        writeType: args.inheritedTypes?.writeType ?? declared,
         hasGetter,
         isWritable,
-        getterMember: delegates.getter?.member,
-        setterMember: delegates.setter?.member,
     };
 };
 
@@ -234,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) {
@@ -242,11 +102,10 @@ const resolveOwnerAccessor = (
             continue;
         }
 
-        methodByName.set(method.name, method);
         claimedNames.add(methodExportName(method));
     }
 
-    return resolveAccessor({ context, property, claimedNames, methodByName });
+    return resolveAccessor({ context, property, claimedNames });
 };
 
 const resolveAccessorTypes = (
@@ -284,18 +143,15 @@ const renderResolvedPropertyAccessor = (
     property: GirProperty,
     accessor: ResolvedAccessor,
 ): string => {
-    const { jsName, readType, writeType, hasGetter, isWritable, setterMember } = accessor;
+    const { jsName, readType, writeType, hasGetter, isWritable } = accessor;
     const blocks: string[] = [];
 
     if (hasGetter) {
-        blocks.push(renderBlock(`get ${jsName}(): ${readType}`, renderGetterBody(context, property, accessor)));
+        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: ${writeType})`, setterBody));
+        blocks.push(renderBlock(`set ${jsName}(value: ${writeType})`, renderGenericSetBody(context, property)));
     }
 
     return `${propertyDoc(property)}${blocks.join("\n\n")}`;
@@ -347,33 +203,6 @@ const renderGenericSetBody = (context: ModuleContext, property: GirProperty): st
     return `setObjectProperty(this, ${sourceStringLiteral(property.name)}, ${descriptor}, value);`;
 };
 
-const renderGetterBody = (context: ModuleContext, property: GirProperty, accessor: ResolvedAccessor): string =>
-    accessor.getterMember === undefined
-        ? renderGenericGetBody(context, property, accessor.readType)
-        : `return this.${accessor.getterMember}();`;
-
-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,

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

@@ -11,7 +11,7 @@ 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";
+import { emitFieldWrite, isEmittableField, isInlineField, isStorableFieldType } from "./record-field-accessor.js";
 import { computeRecordFieldSlots, type RecordFieldSlot } from "./record-layout.js";
 import { isConstructibleRecord } from "./value-marshalable.js";
 
@@ -25,7 +25,9 @@ type RecordConstructorSpec = {
 };
 
 const isWritableFieldSlot = (context: ModuleContext, entry: RecordFieldSlot): entry is WritableFieldSlot =>
-    entry.field.writable && isEmittableField(context, entry.field);
+    entry.field.writable &&
+    isEmittableField(context, entry.field) &&
+    isStorableFieldType(context, entry.field.type);
 
 const renderRecordConstructorPropsInterface = (
     context: ModuleContext,
@@ -121,9 +123,9 @@ const renderRecordConstructor = (context: ModuleContext, spec: RecordConstructor
 
     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"));
@@ -151,7 +153,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

@@ -9,6 +9,7 @@ import type { ModuleContext } from "../../writer/context.js";
 import { isInlineCallbackRef, renderDescriptor } from "../../analysis/descriptor-render.js";
 import { tStruct } from "../../analysis/descriptor.js";
 import { renderTsType } from "../../analysis/ts-type.js";
+import { isUnboundedArray } from "../../analysis/type-shape.js";
 import { indent, renderBlock } from "../../writer/emit.js";
 import { getDoc } from "./doc-spec.js";
 import { bitMask, computeRecordFieldSlots, mergeBitfield, type RecordFieldSlot } from "./record-layout.js";
@@ -27,6 +28,10 @@ type AdmittedField = {
     jsName: string;
 };
 
+type AccessibleField = AdmittedField & {
+    isSettable: boolean;
+};
+
 type RecordFieldEntry = {
     jsName: string;
     tsType: string;
@@ -167,12 +172,49 @@ const admitField = (
     return { field, jsName };
 };
 
+const isNullTerminatedArrayField = (context: ModuleContext, ref: TypeId): boolean => {
+    const type = context.library.typeFor(ref);
+
+    return type?.kind === "carray" && isUnboundedArray(type) && type.elementCType?.endsWith("*") === true;
+};
+
+const isAccessibleFieldType = (context: ModuleContext, ref: TypeId): boolean =>
+    isAccessorEligibleType(context, ref) || isNullTerminatedArrayField(context, ref);
+
+const isStorableFieldType = (context: ModuleContext, ref: TypeId): boolean => {
+    const kind = context.library.typeFor(ref)?.kind;
+
+    return kind !== "carray" && kind !== "list" && kind !== "hashtable";
+};
+
+const admitAccessibleField = (
+    context: ModuleContext,
+    slot: RecordFieldSlot,
+    claimedNames: Set<string>,
+    siblingFields: GirField[],
+): AccessibleField | undefined => {
+    const admitted = admitField(context, slot, claimedNames);
+
+    if (admitted === undefined) {
+        return undefined;
+    }
+
+    const { field, jsName } = admitted;
+    const target: StructArrayTarget = { field, jsName, slot: slot.slot, siblingFields };
+    const hasStructArray = resolveStructArray(context, target) !== undefined;
+    const hasAccessor = hasStructArray || isAccessibleFieldType(context, field.type);
+    const isSettable = field.writable && (hasStructArray || isStorableFieldType(context, field.type));
+
+    return hasAccessor ? { ...admitted, isSettable } : undefined;
+};
+
 const resolveRecordFieldEntry = (
     context: ModuleContext,
     slot: RecordFieldSlot,
     claimedNames: Set<string>,
+    siblingFields: GirField[],
 ): RecordFieldEntry | undefined => {
-    const admitted = admitField(context, slot, claimedNames);
+    const admitted = admitAccessibleField(context, slot, claimedNames, siblingFields);
 
     if (admitted === undefined) {
         return undefined;
@@ -181,7 +223,7 @@ const resolveRecordFieldEntry = (
     return {
         jsName: admitted.jsName,
         tsType: renderTsType(context, admitted.field.type, false),
-        isWritable: admitted.field.writable,
+        isWritable: admitted.isSettable,
         doc: admitted.field.doc,
         annotations: admitted.field.annotations,
     };
@@ -193,7 +235,7 @@ const renderRecordFieldAccessor = (
     claimedNames: Set<string>,
     siblingFields: GirField[],
 ): string | undefined => {
-    const admitted = admitField(context, slot, claimedNames);
+    const admitted = admitAccessibleField(context, slot, claimedNames, siblingFields);
 
     if (admitted === undefined) {
         return undefined;
@@ -207,12 +249,6 @@ const renderRecordFieldAccessor = (
         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", { isInline: isInlineField(context, field) }),
     );
@@ -230,7 +266,7 @@ const renderRecordFieldAccessor = (
 
     const blocks: string[] = [getterBlock(accessorOptions)];
 
-    if (field.writable) {
+    if (admitted.isSettable) {
         blocks.push(setterBlock(accessorOptions));
     }
 
@@ -366,6 +402,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)})`;
 
@@ -452,7 +503,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, {
@@ -468,7 +519,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");
@@ -543,7 +594,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;
     }
 
@@ -639,6 +690,7 @@ const setterBlock = (options: AccessorOptions): string =>
 export {
     isEmittableField,
     isInlineField,
+    isStorableFieldType,
     emitFieldWrite,
     resolveRecordFieldEntry,
     renderRecordFieldAccessor,