@gtkx/codegen 1.0.0-rc.4 → 1.1.0

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

@@ -6,18 +6,30 @@ 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 { renderJsDoc } from "../../writer/doc.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;
+};
+
+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;
 };
 
@@ -26,18 +38,15 @@ type PropertyAccessorArgs = {
     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 AccessorDelegate = { member: string; method: GirFunction };
+type AccessorDelegates = { getter: AccessorDelegate | undefined; setter: AccessorDelegate | undefined };
+type TypedDelegates = { types: AccessorTypes; delegates: AccessorDelegates };
 
-type GetterBodyOptions = {
-    context: ModuleContext;
-    property: GirProperty;
-    getterMember: string | undefined;
-    getterMethod: GirFunction | undefined;
-    tsType: string;
-};
+const NULLABLE_SUFFIX = " | null";
 
 const isNullablePropertyType = (context: ModuleContext, type: TypeId | undefined): boolean => {
     if (type === undefined) {
@@ -70,14 +79,17 @@ const resolveDelegate = (
     attribute: string | undefined,
     member: string | undefined,
     isDelegatable: (method: GirFunction) => boolean,
-): AccessorDelegate => {
+): AccessorDelegate | undefined => {
     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 };
+    if (member === undefined || method === undefined || !isDelegatable(method)) {
+        return undefined;
+    }
+
+    return { member, method };
 };
 
-const resolveGetterDelegate = (args: PropertyAccessorArgs, jsName: string): AccessorDelegate => {
+const resolveGetterDelegate = (args: PropertyAccessorArgs, jsName: string): AccessorDelegate | undefined => {
     const { context, property, claimedNames } = args;
     const member = delegateMember(property.getter, jsName, claimedNames);
 
@@ -91,7 +103,11 @@ const resolveGetterDelegate = (args: PropertyAccessorArgs, jsName: string): Acce
     );
 };
 
-const resolveSetterDelegate = (args: PropertyAccessorArgs, jsName: string, isWritable: boolean): AccessorDelegate => {
+const resolveSetterDelegate = (
+    args: PropertyAccessorArgs,
+    jsName: string,
+    isWritable: boolean,
+): AccessorDelegate | undefined => {
     const { context, property, claimedNames } = args;
     const member = isWritable ? delegateMember(property.setter, jsName, claimedNames) : undefined;
 
@@ -103,52 +119,114 @@ const resolveSetterDelegate = (args: PropertyAccessorArgs, jsName: string, isWri
     );
 };
 
-const resolveOwnType = (
+const baseTypeName = (type: string): string =>
+    type.endsWith(NULLABLE_SUFFIX) ? type.slice(0, -NULLABLE_SUFFIX.length) : type;
+
+const areDelegateBaseTypesAgreeing = (
     context: ModuleContext,
-    property: GirProperty,
-    getterMethod: GirFunction | undefined,
-    setterMethod: GirFunction | undefined,
-): string => {
-    const setterParam = setterMethod?.parameters[0];
+    getter: AccessorDelegate | undefined,
+    setter: AccessorDelegate | undefined,
+): boolean => {
+    const setterParam = setter?.method.parameters[0];
 
-    if (setterParam !== undefined) {
-        return renderTsType(context, setterParam.type, setterParam.nullable || setterParam.optional);
+    if (setterParam === undefined || getter === undefined) {
+        return true;
     }
 
-    if (getterMethod !== undefined) {
-        return renderMethodReturnType(context, getterMethod);
+    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 renderTsType(context, property.type, isNullablePropertyType(context, property.type));
+    return { getter, setter: undefined };
+};
+
+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 isSkippedAccessor = (property: GirProperty, jsName: string, claimedNames: Set<string>): boolean =>
-    !property.introspectable || claimedNames.has(jsName) || jsName === "constructor";
+const isAssignableType = (source: string, target: string): boolean =>
+    source === target || baseTypeName(target) === source;
 
-const resolveTsType = (inheritedType: string | undefined, ownType: string): string =>
-    inheritedType !== undefined && inheritedType !== ownType ? inheritedType : ownType;
+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) };
+};
+
+const isSkippedAccessor = (args: PropertyAccessorArgs, jsName: string): boolean =>
+    !args.property.introspectable ||
+    args.claimedNames.has(jsName) ||
+    args.inheritedNames?.has(jsName) === true ||
+    jsName === "constructor";
 
 const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefined => {
-    const { context, property, claimedNames } = args;
+    const { property } = args;
     const jsName = toCamelIdentifier(property.name);
 
-    if (isSkippedAccessor(property, jsName, claimedNames)) {
+    if (isSkippedAccessor(args, jsName)) {
         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;
+    const { types, delegates } = resolveTypedDelegates(args, resolveDelegates(args, jsName, isWritable));
+    const hasGetter = property.readable || delegates.getter !== undefined;
 
     if (!hasGetter && !isWritable) {
         return undefined;
     }
 
-    const ownType = resolveOwnType(context, property, getterMethod, setterMethod);
-    const tsType = resolveTsType(args.inheritedType, ownType);
-
-    return { jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember };
+    return {
+        property,
+        jsName,
+        readType: types.readType,
+        writeType: types.writeType,
+        hasGetter,
+        isWritable,
+        getterMember: delegates.getter?.member,
+        setterMember: delegates.setter?.member,
+    };
 };
 
 const resolveOwnerAccessor = (
@@ -171,11 +249,22 @@ const resolveOwnerAccessor = (
     return resolveAccessor({ context, property, claimedNames, methodByName });
 };
 
-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,
@@ -195,41 +284,49 @@ const renderResolvedPropertyAccessor = (
     property: GirProperty,
     accessor: ResolvedAccessor,
 ): string => {
-    const { jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember } = accessor;
+    const { jsName, readType, writeType, hasGetter, isWritable, setterMember } = 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}`, renderGetterBody(context, property, accessor)));
     }
 
     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})`, setterBody));
     }
 
-    return `${renderJsDoc(property.doc)}${blocks.join("\n\n")}`;
+    return `${propertyDoc(property)}${blocks.join("\n\n")}`;
 };
 
+const propertyDoc = (property: GirProperty): string =>
+    getDoc(property);
+
 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 = renderJsDoc(args.property.doc);
+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};`;
+    }
+
+    if (readType === writeType) {
+        return `${jsName}: ${readType};`;
+    }
 
-        return `${doc}set ${jsName}(value: ${tsType});`;
-    });
+    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);
@@ -250,21 +347,10 @@ 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 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,
@@ -289,12 +375,14 @@ const delegateMember = (
 };
 
 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,15 @@
 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";
 import { computeRecordFieldSlots, type RecordFieldSlot } from "./record-layout.js";
@@ -13,33 +17,70 @@ 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
         .filter((entry): entry is WritableFieldSlot => isWritableFieldSlot(context, entry))
-        .map((entry) => `${toCamelIdentifier(entry.field.name)}?: ${renderTsType(context, entry.field.type, true)};`);
+        .map(
+            (entry) =>
+                `${getDoc(entry.field)}${toCamelIdentifier(entry.field.name)}?: ` +
+                `${renderTsType(context, entry.field.type, true)};`,
+        );
 
     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"));
 };
@@ -61,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) {

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

@@ -1,5 +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";
@@ -7,8 +9,8 @@ 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 { renderJsDoc } from "../../writer/doc.js";
 import { indent, renderBlock } from "../../writer/emit.js";
+import { getDoc } from "./doc-spec.js";
 import { bitMask, computeRecordFieldSlots, mergeBitfield, type RecordFieldSlot } from "./record-layout.js";
 import { wrapReturnValue } from "./return-wrap.js";
 import { isValueMarshalable } from "./value-marshalable.js";
@@ -30,6 +32,7 @@ type RecordFieldEntry = {
     tsType: string;
     isWritable: boolean;
     doc: string | undefined;
+    annotations: GirAnnotations;
 };
 
 type InlineFieldVisit = {
@@ -180,6 +183,7 @@ const resolveRecordFieldEntry = (
         tsType: renderTsType(context, admitted.field.type, false),
         isWritable: admitted.field.writable,
         doc: admitted.field.doc,
+        annotations: admitted.field.annotations,
     };
 };
 
@@ -196,7 +200,7 @@ const renderRecordFieldAccessor = (
     }
 
     const { field, jsName } = admitted;
-    const doc = renderJsDoc(field.doc);
+    const doc = getDoc(field);
     const structArray = renderStructArrayAccessor(context, { field, jsName, slot: slot.slot, siblingFields });
 
     if (structArray !== undefined) {
@@ -476,6 +480,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);
 
@@ -485,7 +495,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;
     }
 
@@ -632,5 +642,4 @@ export {
     emitFieldWrite,
     resolveRecordFieldEntry,
     renderRecordFieldAccessor,
-    type RecordFieldEntry,
 };

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

@@ -46,6 +46,16 @@ const computeRecordFieldSlots = (
     return { slots, size: result.size };
 };
 
+const recordInlineSize = (context: ModuleContext, record: ResolvedRecordValue): number | undefined => {
+    if (record.opaque || record.disguised || record.fields.length === 0) {
+        return undefined;
+    }
+
+    const { size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+
+    return size > 0 ? size : undefined;
+};
+
 const bitMask = (width: number): number => {
     if (width >= 32) {
         return 0xFF_FF_FF_FF;
@@ -66,7 +76,7 @@ const mergeBitfield = (readExpr: string, valueExpr: string, mask: number, shift:
 
 const fieldLayoutInput = (context: ModuleContext, field: GirField, visited: Set<string>): FieldLayoutInput => {
     if (field.inlineMembers !== undefined) {
-        const layout = inlineMemberLayout(context, field.inlineMembers, field.inlineIsUnion, visited);
+        const layout = inlineMemberLayout(context, field.inlineMembers, field.isInlineUnion, visited);
 
         return { layout, bits: undefined };
     }
@@ -214,4 +224,4 @@ const resolveAliasLayout = (
     return layoutOfType(context, ref, resolved.value.targetCType, visited);
 };
 
-export { computeRecordFieldSlots, bitMask, mergeBitfield, type RecordFieldSlot };
+export { computeRecordFieldSlots, recordInlineSize, bitMask, mergeBitfield, type RecordFieldSlot };

package/src/store/gi/record.ts

@@ -1,27 +1,26 @@
+import { sanitizeTypeIdentifier } from "@gtkx/utils";
 import type { GirRecord } from "../../gir/record.js";
 import type { ModuleContext } from "../../writer/context.js";
-import { renderJsDoc } from "../../writer/doc.js";
+import { isEmittableEntity } from "../../gir/emittable.js";
 import { indentMembers } from "../../writer/emit.js";
 import { type Callables, dedupeCallables, generateBindings, renderPlainTypeMembers } from "./callables.js";
+import { getDoc } from "./doc-spec.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { renderRecordConstructor, renderRecordConstructorPropsInterface } from "./record-constructor.js";
 import { renderRecordFieldAccessor } from "./record-field-accessor.js";
 import { computeRecordFieldSlots } from "./record-layout.js";
 import { appendWrapperClassRegistration } from "./registration.js";
+import { isConstructibleRecord } from "./value-marshalable.js";
 
 const isGErrorRecord = (context: ModuleContext, record: GirRecord): boolean =>
     context.namespace.name === "GLib" && record.glibGetType === "g_error_get_type";
 
 const generateRecord = (context: ModuleContext, record: GirRecord): void => {
-    if (!record.introspectable) {
+    if (!isEmittableEntity(record)) {
         return;
     }
 
-    if (record.name.length === 0) {
-        return;
-    }
-
-    const className = record.name;
+    const className = sanitizeTypeIdentifier(record.name);
     const isErrorSubclass = isGErrorRecord(context, record);
 
     const callables: Callables = {
@@ -34,8 +33,23 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
     const members = renderRecordMembers(context, record, className, callables);
     const body = indentMembers(members);
     const heritage = isErrorSubclass ? " extends globalThis.Error" : "";
-    context.module.appendDeclaration(`${renderJsDoc(record.doc)}export class ${className}${heritage} {\n${body}\n}`);
-    context.module.appendDeclaration(renderRecordConstructorPropsInterface(context, record, className));
+    const doc = getDoc(record);
+    const isConstructible = isConstructibleRecord(context, context.namespace.name, record);
+    const modifier = isConstructible ? "" : "abstract ";
+
+    context.declare({
+        name: className,
+        code: `${doc}export ${modifier}class ${className}${heritage} {\n${body}\n}`,
+        owner: record.name,
+    });
+
+    if (isConstructible) {
+        context.declare({
+            name: `${className}ConstructorProps`,
+            code: renderRecordConstructorPropsInterface(context, record, className),
+        });
+    }
+
     const gtypeExpr = renderSourceGtype(context, record);
 
     appendWrapperClassRegistration(context, {
@@ -59,7 +73,7 @@ const renderRecordMembers = (
         hasGtype: record.glibGetType !== undefined,
     });
 
-    members.unshift(renderRecordConstructor(context, record, className, isErrorSubclass));
+    members.unshift(renderRecordConstructor(context, { record, className, callables, isErrorSubclass }));
     const { slots } = computeRecordFieldSlots(context, record.fields, record.isUnion);
 
     for (const slot of slots) {