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

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

@@ -1,4 +1,7 @@
 import type { GirField } from "../../gir/field.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { EntityType, GirType } from "../../gir/type.js";
+import type { ModuleContext } from "../../writer/context.js";
 import {
     computeFieldSlots,
     type FieldLayout,
@@ -6,80 +9,135 @@ import {
     type FieldSlot,
     layoutOfPrimitive,
 } from "../../gir/size.js";
-import type { EntityType, GirType } from "../../gir/type.js";
-import type { TypeId } from "../../gir/type-id.js";
-import type { ModuleContext } from "../../writer/context.js";
 
-const POINTER_LAYOUT: FieldLayout = { size: 8, align: 8 };
+type ResolvedRecordValue = Extract<EntityType, { kind: "record" }>["value"];
 
-export type RecordFieldSlot = {
+type RecordFieldSlot = {
     field: GirField;
     slot: FieldSlot;
 };
 
-export const computeRecordFieldSlots = (
+const POINTER_LAYOUT: FieldLayout = { size: 8, align: 8 };
+const recordLayoutCache: Map<string, FieldLayout> = new Map();
+
+// GIR carries no alignment attribute, and a type whose alignment exceeds its widest member cannot be
+// derived from the field list: Graphene models `graphene_simd4f_t` as four `gfloat`, which computes
+// to align 4 while the real type is a 16-byte SIMD vector. Keying the override on `c:type` keeps it
+// to the handful of types where the XML genuinely cannot express the ABI.
+const ALIGNMENT_OVERRIDES: Map<string, FieldLayout> = new Map([
+    ["graphene_simd4f_t", { size: 16, align: 16 }],
+    ["graphene_simd4x4f_t", { size: 64, align: 16 }],
+]);
+
+const computeRecordFieldSlots = (
     context: ModuleContext,
     fields: GirField[],
     isUnion = false,
 ): { slots: RecordFieldSlot[]; size: number } => {
-    const inputs: FieldLayoutInput[] = [];
-    for (const field of fields) {
-        inputs.push(fieldLayoutInput(context, field, new Set()));
-    }
+    const inputs: FieldLayoutInput[] = Array.from(fields, (field) => fieldLayoutInput(context, field, new Set()));
     const result = computeFieldSlots(inputs, isUnion);
+
     const slots = result.slots.map((slot, index) => {
         const field = fields[index];
+
         if (field === undefined) {
             throw new Error("computeRecordFieldSlots: parallel arrays diverged");
         }
+
         return { field, slot };
     });
+
     return { slots, size: result.size };
 };
 
-export const bitMask = (width: number): number => {
-    if (width >= 32) return 0xffffffff;
+const bitMask = (width: number): number => {
+    if (width >= 32) {
+        return 0xFF_FF_FF_FF;
+    }
+
     return (1 << width) - 1;
 };
 
-export const mergeBitfield = (readExpr: string, valueExpr: string, mask: number, shift: number): string =>
-    `((${readExpr} & ~(${mask} << ${shift})) | ((Number(${valueExpr}) & ${mask}) << ${shift})) >>> 0`;
+const mergeBitfield = (readExpr: string, valueExpr: string, mask: number, shift: number): string => {
+    const maskExpr = String(mask);
+    const shiftExpr = String(shift);
+
+    return (
+        `((${readExpr} & ~(${maskExpr} << ${shiftExpr})) | ` +
+        `((Number(${valueExpr}) & ${maskExpr}) << ${shiftExpr})) >>> 0`
+    );
+};
 
 const fieldLayoutInput = (context: ModuleContext, field: GirField, visited: Set<string>): FieldLayoutInput => {
+    if (field.inlineMembers !== undefined) {
+        const layout = inlineMemberLayout(context, field.inlineMembers, field.inlineIsUnion, visited);
+
+        return { layout, bits: undefined };
+    }
+
     if (field.type === undefined) {
         return { layout: POINTER_LAYOUT, bits: undefined };
     }
+
     return { layout: layoutOfType(context, field.type, field.cType, visited), bits: field.bits };
 };
 
+const inlineMemberLayout = (
+    context: ModuleContext,
+    members: GirField[],
+    isUnion: boolean,
+    visited: Set<string>,
+): FieldLayout => {
+    const inputs = Array.from(members, (member) => fieldLayoutInput(context, member, visited));
+
+    if (inputs.length === 0) {
+        return { size: 0, align: 1 };
+    }
+
+    const { size } = computeFieldSlots(inputs, isUnion);
+
+    return { size, align: Math.max(1, ...inputs.map((input) => input.layout.align)) };
+};
+
+const pointerOr = (occurrenceCType: string | undefined, otherwise: () => FieldLayout): FieldLayout =>
+    occurrenceCType?.endsWith("*") === true ? POINTER_LAYOUT : otherwise();
+
 const layoutOfType = (
     context: ModuleContext,
     ref: TypeId,
     occurrenceCType: string | undefined,
     visited: Set<string>,
 ): FieldLayout => {
-    const type = context.library.typeOf(ref);
-    if (type === undefined) return POINTER_LAYOUT;
+    const type = context.library.typeFor(ref);
+
+    if (type === undefined) {
+        return POINTER_LAYOUT;
+    }
+
     switch (type.kind) {
-        case "primitive":
-            return layoutOfPrimitive(type.category);
-        case "carray":
+        case "primitive": {
+            return pointerOr(occurrenceCType, () => layoutOfPrimitive(type.category));
+        }
+        case "carray": {
             return arrayLayout(context, type, visited);
+        }
         case "list":
         case "hashtable":
         case "callback":
         case "varargs":
         case "class":
-        case "interface":
+        case "interface": {
             return POINTER_LAYOUT;
-        case "enum":
-            return occurrenceCType?.endsWith("*") === true ? POINTER_LAYOUT : layoutOfPrimitive("int32");
-        case "record":
-            return occurrenceCType?.endsWith("*") === true ? POINTER_LAYOUT : layoutOfRecord(context, type, visited);
-        case "alias":
-            return occurrenceCType?.endsWith("*") === true
-                ? POINTER_LAYOUT
-                : resolveAliasLayout(context, type, visited);
+        }
+        case "enum": {
+            return pointerOr(occurrenceCType, () => layoutOfPrimitive("int32"));
+        }
+        case "record": {
+            return pointerOr(occurrenceCType, () => layoutOfRecord(context, type, visited));
+        }
+        case "alias": {
+            return pointerOr(occurrenceCType, () => resolveAliasLayout(context, type, visited));
+        }
     }
 };
 
@@ -88,47 +146,76 @@ const arrayLayout = (
     ref: Extract<GirType, { kind: "carray" }>,
     visited: Set<string>,
 ): FieldLayout => {
-    if (ref.fixedSize === undefined) return POINTER_LAYOUT;
+    if (ref.fixedSize === undefined) {
+        return POINTER_LAYOUT;
+    }
+
     const elementLayout = layoutOfType(context, ref.element, ref.elementCType, visited);
+
     return { size: elementLayout.size * ref.fixedSize, align: elementLayout.align };
 };
 
+const declaredLayout = (record: ResolvedRecordValue): FieldLayout | undefined => {
+    if (record.cType?.endsWith("*") === true) {
+        return POINTER_LAYOUT;
+    }
+
+    return record.cType === undefined ? undefined : ALIGNMENT_OVERRIDES.get(record.cType);
+};
+
 const layoutOfRecord = (
     context: ModuleContext,
     resolved: Extract<EntityType, { kind: "record" }>,
     visited: Set<string>,
 ): FieldLayout => {
-    if (resolved.value.cType?.endsWith("*") === true) return POINTER_LAYOUT;
+    const declared = declaredLayout(resolved.value);
+
+    if (declared !== undefined) {
+        return declared;
+    }
+
     const key = `${resolved.namespace.name}.${resolved.value.name}`;
-    if (visited.has(key)) return POINTER_LAYOUT;
+
+    if (visited.has(key)) {
+        return POINTER_LAYOUT;
+    }
+
     const cached = recordLayoutCache.get(key);
-    if (cached !== undefined) return cached;
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
     const nextVisited = new Set(visited);
     nextVisited.add(key);
-    const inputs: FieldLayoutInput[] = [];
-    for (const field of resolved.value.fields) {
-        if (field.type === undefined) {
-            inputs.push({ layout: POINTER_LAYOUT, bits: undefined });
-            continue;
-        }
-        inputs.push({ layout: layoutOfType(context, field.type, field.cType, nextVisited), bits: field.bits });
+
+    const inputs: FieldLayoutInput[] = Array.from(resolved.value.fields, (field) =>
+        fieldLayoutInput(context, field, nextVisited));
+
+    if (inputs.length === 0) {
+        return POINTER_LAYOUT;
     }
-    if (inputs.length === 0) return POINTER_LAYOUT;
+
     const { size } = computeFieldSlots(inputs, resolved.value.isUnion);
     const align = Math.max(1, ...inputs.map((input) => input.layout.align));
     const layout: FieldLayout = { size, align };
     recordLayoutCache.set(key, layout);
+
     return layout;
 };
 
-const recordLayoutCache = new Map<string, FieldLayout>();
-
 const resolveAliasLayout = (
     context: ModuleContext,
     resolved: Extract<EntityType, { kind: "alias" }>,
     visited: Set<string>,
 ): FieldLayout => {
     const ref = resolved.value.target;
-    if (ref === undefined) return POINTER_LAYOUT;
+
+    if (ref === undefined) {
+        return POINTER_LAYOUT;
+    }
+
     return layoutOfType(context, ref, resolved.value.targetCType, visited);
 };
+
+export { computeRecordFieldSlots, bitMask, mergeBitfield, type RecordFieldSlot };

package/src/store/gi/record.ts

@@ -4,7 +4,7 @@ import { renderJsDoc } from "../../writer/doc.js";
 import { indentMembers } from "../../writer/emit.js";
 import { type Callables, dedupeCallables, generateBindings, renderPlainTypeMembers } from "./callables.js";
 import { isClassStructRecord } from "./class-struct-record.js";
-import { gtypeExprFor } from "./gtype-binding.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";
@@ -13,27 +13,40 @@ import { appendWrapperClassRegistration } from "./registration.js";
 const isGErrorRecord = (context: ModuleContext, record: GirRecord): boolean =>
     context.namespace.name === "GLib" && record.glibGetType === "g_error_get_type";
 
-export const generateRecord = (context: ModuleContext, record: GirRecord): void => {
-    if (!record.introspectable) return;
-    if (record.isVtable) return;
-    if (record.name.length === 0) return;
-    if (isClassStructRecord(context.library, context.namespace.name, record)) return;
+const generateRecord = (context: ModuleContext, record: GirRecord): void => {
+    if (!record.introspectable) {
+        return;
+    }
+
+    if (record.isVtable) {
+        return;
+    }
+
+    if (record.name.length === 0) {
+        return;
+    }
+
+    if (isClassStructRecord(context.library, context.namespace.name, record)) {
+        return;
+    }
+
     const className = record.name;
-    const extendsError = isGErrorRecord(context, record);
+    const isErrorSubclass = isGErrorRecord(context, record);
+
     const callables: Callables = {
         constructors: dedupeCallables(record.constructors),
         functions: dedupeCallables(record.functions),
         methods: dedupeCallables(record.methods),
     };
-    generateBindings(context, callables);
 
+    generateBindings(context, callables);
     const members = renderRecordMembers(context, record, className, callables);
     const body = indentMembers(members);
-    const heritage = extendsError ? " extends globalThis.Error" : "";
+    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 gtypeExpr = renderSourceGtype(context, record);
 
-    const gtypeExpr = gtypeExprFor(context, record);
     appendWrapperClassRegistration(context, {
         className,
         gtypeExpr,
@@ -46,21 +59,31 @@ const renderRecordMembers = (
     className: string,
     callables: Callables,
 ): string[] => {
-    const extendsError = isGErrorRecord(context, record);
+    const isErrorSubclass = isGErrorRecord(context, record);
+
     const { members, claimedNames } = renderPlainTypeMembers({
         context,
         className,
         callables,
         hasGtype: record.glibGetType !== undefined,
     });
-    members.unshift(renderRecordConstructor(context, record, className, extendsError));
+
+    members.unshift(renderRecordConstructor(context, record, className, isErrorSubclass));
     const { slots } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+
     for (const slot of slots) {
         const block = renderRecordFieldAccessor(context, slot, claimedNames, record.fields);
-        if (block !== undefined) members.push(block);
+
+        if (block !== undefined) {
+            members.push(block);
+        }
     }
-    if (extendsError) {
+
+    if (isErrorSubclass) {
         members.push('get name(): string {\n    return "GLib.Error";\n}');
     }
+
     return members;
 };
+
+export { generateRecord };

package/src/store/gi/registration.ts

@@ -6,33 +6,39 @@ type WrapperClassRegistration = {
     vfuncs?: string | undefined;
 };
 
-export const appendWrapperClassRegistration = (
+type InterfaceRegistration = {
+    className: string;
+    makerName: string;
+    gtypeExpr?: string | undefined;
+    vfuncs?: string | undefined;
+};
+
+const appendWrapperClassRegistration = (
     context: ModuleContext,
     registration: WrapperClassRegistration,
 ): void => {
     const { className, gtypeExpr, vfuncs } = registration;
+
     if (gtypeExpr === undefined) {
         return;
     }
+
     context.addRuntimeImport("registerWrapperClass");
     const args = vfuncs === undefined ? gtypeExpr : `${gtypeExpr}, ${vfuncs}`;
     context.module.appendRegistration(`registerWrapperClass(${className}, ${args});`);
 };
 
-type InterfaceRegistration = {
-    className: string;
-    makerName: string;
-    gtypeExpr?: string | undefined;
-    vfuncs?: string | undefined;
-};
-
-export const appendInterfaceRegistration = (context: ModuleContext, registration: InterfaceRegistration): void => {
+const appendInterfaceRegistration = (context: ModuleContext, registration: InterfaceRegistration): void => {
     const { className, makerName, gtypeExpr, vfuncs } = registration;
+
     if (gtypeExpr === undefined) {
         return;
     }
+
     context.addRuntimeImport("registerInterface");
     const base = `${className}, ${gtypeExpr}, ${makerName}`;
     const args = vfuncs === undefined ? base : `${base}, ${vfuncs}`;
     context.module.appendRegistration(`registerInterface(${args});`);
 };
+
+export { appendWrapperClassRegistration, appendInterfaceRegistration };

package/src/store/gi/return-wrap.ts

@@ -1,8 +1,8 @@
-import { renderDescriptor } from "../../analysis/descriptor-render.js";
-import { renderTsType } from "../../analysis/ts-type.js";
 import type { PrimitiveCategory } from "../../gir/primitives.js";
 import type { TypeId } from "../../gir/type-id.js";
 import type { ModuleContext } from "../../writer/context.js";
+import { renderDescriptor } from "../../analysis/descriptor-render.js";
+import { renderTsType } from "../../analysis/ts-type.js";
 
 type WrapReturnOptions = {
     ref: TypeId | undefined;
@@ -10,43 +10,91 @@ type WrapReturnOptions = {
     valueExpression: string;
 };
 
-export const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): string => {
+const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["gtype", "bigint64", "biguint64"]);
+
+const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): string => {
     const { ref, nullable, valueExpression } = options;
-    if (ref === undefined) return valueExpression;
-    const type = context.library.typeOf(ref);
-    if (type === undefined) return wrapValue(context, ref, valueExpression);
+
+    if (ref === undefined) {
+        return valueExpression;
+    }
+
+    const type = context.library.typeFor(ref);
+
+    if (type === undefined) {
+        return wrapValue(context, ref, valueExpression);
+    }
+
     switch (type.kind) {
-        case "primitive":
+        case "primitive": {
             return wrapPrimitive(type.category, nullable, valueExpression);
-        case "varargs":
+        }
+        case "varargs": {
             return `(${valueExpression} as unknown[])`;
-        case "callback":
-            return context.library.nameOf(ref) === undefined
-                ? `(${valueExpression} as unknown[])`
-                : `(${valueExpression} as ${renderTsType(context, ref, false)})`;
-        case "enum":
+        }
+        case "callback": {
+            return wrapCallback(context, ref, valueExpression);
+        }
+        case "enum": {
             return `(${valueExpression} as number)`;
-        case "alias":
-            return type.value.target === undefined
-                ? valueExpression
-                : wrapReturnValue(context, { ref: type.value.target, nullable, valueExpression });
-        default:
+        }
+        case "alias": {
+            return wrapAlias(context, type.value.target, nullable, valueExpression);
+        }
+        case "carray":
+        case "class":
+        case "hashtable":
+        case "interface":
+        case "list":
+        case "record": {
             return wrapValue(context, ref, valueExpression);
+        }
     }
 };
 
+const wrapCallback = (context: ModuleContext, ref: TypeId, valueExpression: string): string =>
+    context.library.nameFor(ref) === undefined
+        ? `(${valueExpression} as unknown[])`
+        : `(${valueExpression} as ${renderTsType(context, ref, false)})`;
+
+const wrapAlias = (
+    context: ModuleContext,
+    target: TypeId | undefined,
+    isNullable: boolean,
+    valueExpression: string,
+): string =>
+    target === undefined
+        ? valueExpression
+        : wrapReturnValue(context, { ref: target, nullable: isNullable, valueExpression });
+
 const wrapValue = (context: ModuleContext, ref: TypeId, valueExpression: string): string => {
     context.addRuntimeImport("fromNative");
     const descriptor = context.hoistDescriptor(renderDescriptor(context, ref, "none"));
+
     return `(fromNative(${descriptor}, ${valueExpression}) as ${renderTsType(context, ref, false)})`;
 };
 
-const wrapPrimitive = (category: PrimitiveCategory, nullable: boolean, valueExpression: string): string => {
-    if (category === "void") return valueExpression;
-    if (category === "string") return `(${valueExpression} as ${nullable ? "string | null" : "string"})`;
-    if (category === "boolean") return `Boolean(${valueExpression})`;
-    if (category === "gtype" || category === "bigint64" || category === "biguint64") {
+const wrapStringPrimitive = (isNullable: boolean, valueExpression: string): string =>
+    `(${valueExpression} as ${isNullable ? "string | null" : "string"})`;
+
+const wrapPrimitive = (category: PrimitiveCategory, isNullable: boolean, valueExpression: string): string => {
+    if (category === "void") {
+        return valueExpression;
+    }
+
+    if (category === "string") {
+        return wrapStringPrimitive(isNullable, valueExpression);
+    }
+
+    if (category === "boolean") {
+        return `Boolean(${valueExpression})`;
+    }
+
+    if (BIGINT_CATEGORIES.has(category)) {
         return `(${valueExpression} as bigint)`;
     }
+
     return `(${valueExpression} as number)`;
 };
+
+export { wrapReturnValue };

package/src/store/gi/runtime-override.ts

@@ -27,10 +27,20 @@ const RUNTIME_OVERRIDES: Map<string, RuntimeOverride> = new Map([
     ],
 ]);
 
-export const renderRuntimeOverride = (callable: GirFunction, memberName: string): string | undefined => {
-    if (callable.cIdentifier === undefined) return undefined;
+const renderRuntimeOverride = (callable: GirFunction, memberName: string): string | undefined => {
+    if (callable.cIdentifier === undefined) {
+        return undefined;
+    }
+
     const override = RUNTIME_OVERRIDES.get(callable.cIdentifier);
-    if (override === undefined) return undefined;
+
+    if (override === undefined) {
+        return undefined;
+    }
+
     const generics = override.generics ?? "";
+
     return `${memberName}${generics}(${override.signature}): ${override.returnType} {\n    ${override.body}\n}`;
 };
+
+export { renderRuntimeOverride };