@gtkx/codegen 0.21.0 → 1.0.0-rc.2

package/src/fingerprint.ts

@@ -1,50 +1,159 @@
+import { sortStrings } from "@gtkx/utils";
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
+import { type Dirent, existsSync, readdirSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The freshness sentinel of the `@gtkx/gi` store, derived purely from the GIR inputs. */
+type GiFingerprint = {
+    value: string;
+    girFiles: string[];
+    libraries: string[];
+    girPath?: string[];
+};
+
+type ModuleExport = { module: string; export: string };
+
+/** The `@gtkx/react` element config that shapes the generated `@gtkx/jsx` store. */
+type JsxFingerprintInput = {
+    reactVersion: string;
+    components: Record<string, ModuleExport>;
+    lazyElements: string[];
+    props: Record<string, ModuleExport>;
+};
+
+/** The freshness sentinel of the `@gtkx/jsx` store, derived from the React element config. */
+type JsxFingerprint = {
+    value: string;
+    intrinsicElementCount: number;
+};
 
 const require = createRequire(import.meta.url);
+const FINGERPRINT_FILENAME = ".codegen-fingerprint.json";
+const CODEGEN_VERSION: string = (require("../package.json") as { version: string }).version;
+const OVERRIDES_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "overrides");
+
+const sortAlpha = (values: string[]): string => sortStrings(values).join(",");
 
-/** Filename of the staleness sentinel written into the `@gtkx/gi` store root. */
-export const FINGERPRINT_FILENAME = ".codegen-fingerprint.json";
-
-/**
- * The `@gtkx/codegen` package version, mixed into the store fingerprint so a
- * codegen upgrade invalidates a previously-generated store.
- */
-export const CODEGEN_VERSION: string = (require("../package.json") as { version: string }).version;
-
-/**
- * The staleness sentinel written into the generated `@gtkx/gi` store: the
- * fingerprint value plus the inputs that produced it, so a consumer can
- * recompute and compare without reloading the GIR repository.
- */
-export type CodegenFingerprint = {
-    /** The fingerprint hash of {@link CODEGEN_VERSION}, libraries, and GIR contents. */
-    readonly value: string;
-    /** Absolute paths of every loaded `.gir` file, in load order. */
-    readonly girFiles: readonly string[];
-    /** The resolved `Name-Version` library identifiers the store was built for. */
-    readonly libraries: readonly string[];
-};
-
-/**
- * Computes a content fingerprint over the codegen version, the resolved library
- * set, and the contents of every loaded GIR file. A change to any of these
- * means the generated bindings are stale and must be regenerated.
- *
- * @param girFiles - Absolute paths of the loaded `.gir` files
- * @param libraries - The resolved `Name-Version` library identifiers
- */
-export const computeFingerprint = (girFiles: readonly string[], libraries: readonly string[]): string => {
+// The overrides are copied verbatim into the store, so editing one changes the output even though no
+// GIR file moved. Without them in the hash a stale override survives every non-forced run.
+const overrideFiles = (): string[] => {
+    if (!existsSync(OVERRIDES_ROOT)) {
+        return [];
+    }
+
+    return readdirSync(OVERRIDES_ROOT, { recursive: true, withFileTypes: true })
+        .filter((entry: Dirent) => entry.isFile())
+        .map((entry: Dirent) => join(entry.parentPath, entry.name));
+};
+
+const hashGi = (girFiles: string[], libraries: string[], girPath: string[]): string => {
     const hash = createHash("sha256");
     hash.update(CODEGEN_VERSION);
     hash.update("\n");
-    hash.update([...libraries].sort((a, b) => a.localeCompare(b)).join(","));
-    for (const file of [...girFiles].sort((a, b) => a.localeCompare(b))) {
+    hash.update(sortAlpha(libraries));
+    hash.update("\n");
+    hash.update(sortAlpha(girPath));
+    const hashedFiles = sortStrings([...girFiles, ...overrideFiles()]);
+
+    for (const file of hashedFiles) {
         hash.update("\n");
         hash.update(file);
         hash.update("\0");
         hash.update(readFileSync(file));
     }
+
     return hash.digest("hex");
 };
+
+const computeGiFingerprint = (girFiles: string[], libraries: string[], girPath: string[]): GiFingerprint => ({
+    value: hashGi(girFiles, libraries, girPath),
+    girFiles,
+    libraries,
+    girPath,
+});
+
+const isGiStoreFresh = (giStoreDir: string, libraries: string[], girPath: string[]): boolean => {
+    const sentinelPath = join(giStoreDir, FINGERPRINT_FILENAME);
+
+    if (!existsSync(sentinelPath)) {
+        return false;
+    }
+
+    let sentinel: GiFingerprint;
+
+    try {
+        sentinel = JSON.parse(readFileSync(sentinelPath, "utf8")) as GiFingerprint;
+    } catch {
+        return false;
+    }
+
+    if (!hasMatchingRecordedInputs(sentinel, libraries, girPath)) {
+        return false;
+    }
+
+    try {
+        return hashGi(sentinel.girFiles, sentinel.libraries, girPath) === sentinel.value;
+    } catch {
+        return false;
+    }
+};
+
+const hasMatchingRecordedInputs = (sentinel: GiFingerprint, libraries: string[], girPath: string[]): boolean =>
+    sortAlpha(sentinel.libraries) === sortAlpha(libraries) && sortAlpha(sentinel.girPath ?? []) === sortAlpha(girPath);
+
+const serializeModuleExports = (map: Record<string, ModuleExport>): [string, string, string][] =>
+    sortStrings(Object.keys(map)).map((type) => [type, map[type]?.module ?? "", map[type]?.export ?? ""]);
+
+const hashJsx = (input: JsxFingerprintInput): string =>
+    createHash("sha256")
+        .update(
+            JSON.stringify([
+                CODEGEN_VERSION,
+                input.reactVersion,
+                serializeModuleExports(input.components),
+                sortStrings(input.lazyElements),
+                serializeModuleExports(input.props),
+            ]),
+        )
+        .digest("hex");
+
+const computeJsxFingerprint = (input: JsxFingerprintInput, intrinsicElementCount: number): JsxFingerprint => ({
+    value: hashJsx(input),
+    intrinsicElementCount,
+});
+
+const jsxStoreFreshness = (
+    jsxStoreDir: string,
+    input: JsxFingerprintInput,
+): { fresh: boolean; intrinsicElementCount: number } => {
+    const sentinelPath = join(jsxStoreDir, FINGERPRINT_FILENAME);
+
+    if (!existsSync(sentinelPath)) {
+        return { fresh: false, intrinsicElementCount: 0 };
+    }
+
+    let sentinel: JsxFingerprint;
+
+    try {
+        sentinel = JSON.parse(readFileSync(sentinelPath, "utf8")) as JsxFingerprint;
+    } catch {
+        return { fresh: false, intrinsicElementCount: 0 };
+    }
+
+    return sentinel.value === hashJsx(input)
+        ? { fresh: true, intrinsicElementCount: sentinel.intrinsicElementCount }
+        : { fresh: false, intrinsicElementCount: 0 };
+};
+
+export {
+    FINGERPRINT_FILENAME,
+    computeGiFingerprint,
+    isGiStoreFresh,
+    computeJsxFingerprint,
+    jsxStoreFreshness,
+    type GiFingerprint,
+    type JsxFingerprintInput,
+    type JsxFingerprint,
+};

package/src/gi.ts

@@ -0,0 +1,26 @@
+import type { Library } from "./gir/library.js";
+import { computeGiFingerprint } from "./fingerprint.js";
+import { namespaceDirectory } from "./gir/namespace.js";
+import { type GiNamespaceInput, type GiStoreOptions, writeGiStore } from "./store/gi-store.js";
+import { generateNamespaceModule } from "./store/gi/pipeline.js";
+
+/**
+ * Generates the `@gtkx/gi` store from the loaded GIR library and links it into the project. This is the
+ * react-free half of codegen: it can run before `@gtkx/gi` (or `@gtkx/react`) exists, since it produces them.
+ *
+ * @returns The number of namespaces written.
+ */
+const runGiCodegen = (library: Library, gi: GiStoreOptions, libraries: string[], girPath: string[]): number => {
+    const namespaces: GiNamespaceInput[] = Array.from(library.namespaces.values(), (namespace) => ({
+        directory: namespaceDirectory(namespace),
+        rawSource: generateNamespaceModule(namespace, library),
+    }));
+
+    writeGiStore(gi, namespaces, computeGiFingerprint(library.girFiles, [...libraries], [...girPath]));
+
+    return library.namespaces.size;
+};
+
+export { isGiStoreFresh } from "./fingerprint.js";
+export type { GiStoreOptions } from "./store/gi-store.js";
+export { runGiCodegen };

package/src/gir/ancestry.ts

@@ -0,0 +1,53 @@
+import type { GirClass } from "./class.js";
+import type { Library } from "./library.js";
+import type { GirType } from "./type.js";
+
+type ResolvedAncestor = {
+    klass: GirClass;
+    namespaceName: string;
+};
+
+const getAncestor = (resolved: GirType | undefined): ResolvedAncestor | undefined =>
+    resolved !== undefined && (resolved.kind === "class" || resolved.kind === "interface")
+        ? { klass: resolved.value, namespaceName: resolved.namespace.name }
+        : undefined;
+
+const resolveClassOrInterface = (
+    library: Library,
+    defaultNamespace: string,
+    name: string,
+): ResolvedAncestor | undefined => getAncestor(library.resolveType(defaultNamespace, name));
+
+const resolveInterface = (
+    library: Library,
+    defaultNamespace: string,
+    name: string,
+): ResolvedAncestor | undefined => {
+    const resolved = library.resolveType(defaultNamespace, name);
+
+    return resolved?.kind === "interface" ? getAncestor(resolved) : undefined;
+};
+
+function* ancestorChain(library: Library, klass: GirClass, namespaceName: string): Generator<ResolvedAncestor> {
+    const visited: Set<string> = new Set();
+    let current: ResolvedAncestor | undefined = { klass, namespaceName };
+
+    while (current !== undefined) {
+        const key = `${current.namespaceName}.${current.klass.name}`;
+
+        if (visited.has(key)) {
+            return;
+        }
+
+        visited.add(key);
+        yield current;
+
+        if (current.klass.parent === undefined) {
+            return;
+        }
+
+        current = resolveClassOrInterface(library, current.namespaceName, current.klass.parent);
+    }
+}
+
+export { resolveInterface, ancestorChain, type ResolvedAncestor };

package/src/gir/callback.ts

@@ -1,26 +1,24 @@
-import { type GirParameter, type GirReturnValue, parameterFromNode, returnValueFromNode } from "./parameter.js";
-import { attr, childOf, childrenOf, type RawNode } from "./parse.js";
+import type { GirFunction } from "./function.js";
+import type { RawNode } from "./parse.js";
+import type { ParseContext } from "./type-id.js";
+import { type GirCallable, parseCallable } from "./parameter.js";
 
-/** A `<callback>` declaration (top-level inside a namespace or nested in a field). */
-export type GirCallback = {
-    readonly name: string;
-    readonly cType: string | undefined;
-    readonly parameters: readonly GirParameter[];
-    readonly returnValue: GirReturnValue;
-    readonly introspectable: boolean;
-};
+type GirCallback = GirCallable;
 
-/**
- * Builds a {@link GirCallback} from a `<callback>` element.
- */
-export const callbackFromNode = (node: RawNode): GirCallback => {
-    const parametersNode = childOf(node, "parameters");
-    const parameterNodes = childrenOf(parametersNode, "parameter");
-    return {
-        name: attr(node, "name") ?? "",
-        cType: attr(node, "c:type"),
-        parameters: parameterNodes.map((parameter) => parameterFromNode(parameter, false)),
-        returnValue: returnValueFromNode(childOf(node, "return-value")),
-        introspectable: attr(node, "introspectable") !== "0",
-    };
-};
+const callbackFromNode = (node: RawNode, context: ParseContext): GirCallback => parseCallable(node, context);
+
+const callbackAsFunction = (callback: GirCallback): GirFunction => ({
+    name: callback.name,
+    doc: callback.doc,
+    cIdentifier: undefined,
+    movedTo: undefined,
+    throws: callback.throws,
+    introspectable: callback.introspectable,
+    shadowedBy: undefined,
+    finishFunc: undefined,
+    instance: undefined,
+    parameters: callback.parameters,
+    returnValue: callback.returnValue,
+});
+
+export { callbackFromNode, callbackAsFunction, type GirCallback };

package/src/gir/class.ts

@@ -1,54 +1,35 @@
-import { fieldFromNode, type GirField } from "./field.js";
+import type { ParseContext } from "./type-id.js";
 import { functionFromNode, type GirFunction } from "./function.js";
-import { attr, attrBool, childrenOf, GIR_CONSTRUCTOR_TAG, type RawNode } from "./parse.js";
+import { type GirCallable, parseCallable } from "./parameter.js";
+import { attr, getChildren, getDoc, GIR_CONSTRUCTOR_TAG, isAttrTrue, nameAttr, type RawNode } from "./parse.js";
 import { type GirProperty, propertyFromNode } from "./property.js";
-import { type GirSignal, signalFromNode } from "./signal.js";
 
-/** A `<class>` or `<interface>` declaration. */
-export type GirClass = {
-    /** Local name inside the namespace (no prefix). */
-    readonly name: string;
-    readonly cType: string | undefined;
-    /** GIR `parent`, possibly cross-namespace (e.g. `"GObject.InitiallyUnowned"`). */
-    readonly parent: string | undefined;
-    /** GLib type name (e.g. `"GtkWidget"`). */
-    readonly glibTypeName: string | undefined;
-    /** C symbol that returns the GType integer (e.g. `"gtk_widget_get_type"`). */
-    readonly glibGetType: string | undefined;
-    /** Local record name that holds this class's vtable (`glib:type-struct`). */
-    readonly glibTypeStruct: string | undefined;
-    /** Glib ref/unref/etc. function names on fundamentals; not used for GObject subclasses. */
-    readonly glibRefFunc: string | undefined;
-    readonly glibUnrefFunc: string | undefined;
-    readonly glibSetValueFunc: string | undefined;
-    readonly glibGetValueFunc: string | undefined;
-    /** `glib:fundamental="1"` — a non-GObject fundamental type (e.g. `GdkEvent`, `GskRenderNode`). */
-    readonly fundamental: boolean;
-    readonly abstract: boolean;
-    readonly final: boolean;
-    readonly isInterface: boolean;
-    readonly introspectable: boolean;
-    /** Names of interfaces this class implements (cross-namespace possible). */
-    readonly implements: readonly string[];
-    /** Names of interfaces a `<interface>` requires (`<prerequisite>` elements). */
-    readonly prerequisites: readonly string[];
-    readonly methods: readonly GirFunction[];
-    readonly constructors: readonly GirFunction[];
-    readonly functions: readonly GirFunction[];
-    readonly virtualMethods: readonly GirFunction[];
-    readonly properties: readonly GirProperty[];
-    readonly signals: readonly GirSignal[];
-    readonly fields: readonly GirField[];
+type GirClass = {
+    name: string;
+    doc: string | undefined;
+    cType: string | undefined;
+    parent: string | undefined;
+    glibTypeName: string | undefined;
+    glibGetType: string | undefined;
+    glibTypeStruct: string | undefined;
+    glibRefFunc: string | undefined;
+    glibUnrefFunc: string | undefined;
+    fundamental: boolean;
+    isAbstract: boolean;
+    isInterface: boolean;
+    introspectable: boolean;
+    implements: string[];
+    prerequisites: string[];
+    methods: GirFunction[];
+    constructors: GirFunction[];
+    functions: GirFunction[];
+    properties: GirProperty[];
+    signals: GirCallable[];
 };
 
-/**
- * Builds a {@link GirClass} from a `<class>` or `<interface>` element.
- *
- * @param node - The XML element
- * @param isInterface - `true` when the source element was `<interface>`
- */
-export const classFromNode = (node: RawNode, isInterface: boolean): GirClass => ({
-    name: attr(node, "name") ?? "",
+const classFromNode = (node: RawNode, isInterface: boolean, context: ParseContext): GirClass => ({
+    name: nameAttr(node),
+    doc: getDoc(node),
     cType: attr(node, "c:type"),
     parent: attr(node, "parent"),
     glibTypeName: attr(node, "glib:type-name"),
@@ -56,24 +37,21 @@ export const classFromNode = (node: RawNode, isInterface: boolean): GirClass =>
     glibTypeStruct: attr(node, "glib:type-struct"),
     glibRefFunc: attr(node, "glib:ref-func"),
     glibUnrefFunc: attr(node, "glib:unref-func"),
-    glibSetValueFunc: attr(node, "glib:set-value-func"),
-    glibGetValueFunc: attr(node, "glib:get-value-func"),
-    fundamental: attrBool(node, "glib:fundamental"),
-    abstract: attrBool(node, "abstract"),
-    final: attrBool(node, "final"),
+    fundamental: isAttrTrue(node, "glib:fundamental"),
+    isAbstract: isAttrTrue(node, "abstract"),
     isInterface,
-    introspectable: attr(node, "introspectable") !== "0",
-    implements: childrenOf(node, "implements")
+    introspectable: isAttrTrue(node, "introspectable", true),
+    implements: getChildren(node, "implements")
         .map((implement) => attr(implement, "name"))
         .filter((name): name is string => name !== undefined),
-    prerequisites: childrenOf(node, "prerequisite")
+    prerequisites: getChildren(node, "prerequisite")
         .map((prerequisite) => attr(prerequisite, "name"))
         .filter((name): name is string => name !== undefined),
-    methods: childrenOf(node, "method").map((method) => functionFromNode(method, "method")),
-    constructors: childrenOf(node, GIR_CONSTRUCTOR_TAG).map((ctor) => functionFromNode(ctor, "constructor")),
-    functions: childrenOf(node, "function").map((function_) => functionFromNode(function_, "function")),
-    virtualMethods: childrenOf(node, "virtual-method").map((vmethod) => functionFromNode(vmethod, "virtual-method")),
-    properties: childrenOf(node, "property").map(propertyFromNode),
-    signals: childrenOf(node, "glib:signal").map(signalFromNode),
-    fields: childrenOf(node, "field").map(fieldFromNode),
+    methods: getChildren(node, "method").map((method) => functionFromNode(method, context)),
+    constructors: getChildren(node, GIR_CONSTRUCTOR_TAG).map((ctor) => functionFromNode(ctor, context)),
+    functions: getChildren(node, "function").map((fn) => functionFromNode(fn, context)),
+    properties: getChildren(node, "property").map((property) => propertyFromNode(property, context)),
+    signals: getChildren(node, "glib:signal").map((signal) => parseCallable(signal, context)),
 });
+
+export { classFromNode, type GirClass };

package/src/gir/enum.ts

@@ -1,55 +1,39 @@
-import { functionFromNode, type GirFunction } from "./function.js";
-import { attr, childrenOf, type RawNode } from "./parse.js";
+import { attr, getChildren, getDoc, isAttrTrue, nameAttr, type RawNode } from "./parse.js";
 
-/** A single `<member>` of an `<enumeration>` or `<bitfield>`. */
 type EnumMember = {
-    /** GIR `name`, snake_case lowercase (e.g. `"fill"`). */
-    readonly name: string;
-    /** GIR `c:identifier`, SCREAMING_SNAKE_CASE (e.g. `"GTK_ALIGN_FILL"`). */
-    readonly cIdentifier: string | undefined;
-    /** Numeric value as a string; preserved verbatim from GIR. */
-    readonly value: string;
+    name: string;
+    doc: string | undefined;
+    value: string;
+    cIdentifier: string | undefined;
 };
 
-/** Discriminator for enums vs bitfields. */
-export type EnumKind = "enumeration" | "bitfield";
+type EnumKind = "enumeration" | "bitfield";
 
-/** An `<enumeration>` or `<bitfield>` declaration. */
-export type GirEnum = {
-    readonly kind: EnumKind;
-    /** Local name within the namespace (no namespace prefix). */
-    readonly name: string;
-    readonly cType: string | undefined;
-    /** GLib type name (e.g. `"GtkAlign"`); absent for unregistered enums. */
-    readonly glibTypeName: string | undefined;
-    /** GLib get-type C symbol; absent for unregistered enums. */
-    readonly glibGetType: string | undefined;
-    /** Optional `glib:error-domain` marker; presence flips emission to `createErrorDomain`. */
-    readonly errorDomain: string | undefined;
-    readonly introspectable: boolean;
-    readonly members: readonly EnumMember[];
-    /** Free functions nested inside the enum (e.g. error quark accessors). */
-    readonly functions: readonly GirFunction[];
+type GirEnum = {
+    kind: EnumKind;
+    name: string;
+    doc: string | undefined;
+    glibTypeName: string | undefined;
+    glibGetType: string | undefined;
+    errorDomain: string | undefined;
+    introspectable: boolean;
+    members: EnumMember[];
 };
 
-/**
- * Builds a {@link GirEnum} from an `<enumeration>` or `<bitfield>` element.
- *
- * @param node - The XML element
- * @param kind - `"enumeration"` or `"bitfield"`, matching the element name
- */
-export const enumFromNode = (node: RawNode, kind: EnumKind): GirEnum => ({
+const enumFromNode = (node: RawNode, kind: EnumKind): GirEnum => ({
     kind,
-    name: attr(node, "name") ?? "",
-    cType: attr(node, "c:type"),
+    name: nameAttr(node),
+    doc: getDoc(node),
     glibTypeName: attr(node, "glib:type-name"),
     glibGetType: attr(node, "glib:get-type"),
     errorDomain: attr(node, "glib:error-domain"),
-    introspectable: attr(node, "introspectable") !== "0",
-    members: childrenOf(node, "member").map((member) => ({
-        name: attr(member, "name") ?? "",
-        cIdentifier: attr(member, "c:identifier"),
+    introspectable: isAttrTrue(node, "introspectable", true),
+    members: getChildren(node, "member").map((member) => ({
+        name: nameAttr(member),
+        doc: getDoc(member),
         value: attr(member, "value") ?? "0",
+        cIdentifier: attr(member, "c:identifier"),
     })),
-    functions: childrenOf(node, "function").map((function_) => functionFromNode(function_, "function")),
 });
+
+export { enumFromNode, type GirEnum };

package/src/gir/field.ts

@@ -1,40 +1,54 @@
-import { attr, attrBool, childOf, type RawNode } from "./parse.js";
-import { type GirTypeRef, typeRefFromSlot } from "./type-ref.js";
+import type { ParseContext, TypeId } from "./type-id.js";
+import { attr, getChild, getChildren, getDoc, intAttr, isAttrTrue, nameAttr, type RawNode } from "./parse.js";
+import { typeRefFromNode } from "./type-ref.js";
 
-/**
- * A `<field>` inside a class, interface, record, or union.
- *
- * Vtable slots (fields holding `<callback>` children inside a
- * `glib:is-gtype-struct-for` record) keep `callback` populated; ordinary
- * data fields keep `type`. The two are mutually exclusive.
- */
-export type GirField = {
-    /** GIR field name, snake_case. */
-    readonly name: string;
-    /** Field type, or `undefined` when the field is a vtable callback slot. */
-    readonly type: GirTypeRef | undefined;
-    /** Inline callback for vtable slots; `undefined` for data fields. */
-    readonly callback: RawNode | undefined;
-    readonly readable: boolean;
-    readonly writable: boolean;
-    readonly private: boolean;
-    /** GIR `bits` attribute width when the field is a bitfield member. */
-    readonly bits: number | undefined;
+type GirField = {
+    name: string;
+    doc: string | undefined;
+    type: TypeId | undefined;
+    cType: string | undefined;
+    readable: boolean;
+    writable: boolean;
+    private: boolean;
+    bits: number | undefined;
+    /** Members of an anonymous nested `<union>`/`<record>`, which occupies a slot but has no type. */
+    inlineMembers: GirField[] | undefined;
+    inlineIsUnion: boolean;
 };
 
-/**
- * Builds a {@link GirField} from a `<field>` element.
- */
-export const fieldFromNode = (node: RawNode): GirField => {
-    const callback = childOf(node, "callback");
-    const bitsAttr = attr(node, "bits");
-    return {
-        name: attr(node, "name") ?? "",
-        type: callback === undefined ? typeRefFromSlot(node) : undefined,
-        callback,
-        readable: attrBool(node, "readable", true),
-        writable: attrBool(node, "writable", false),
-        private: attrBool(node, "private", false),
-        bits: bitsAttr === undefined ? undefined : Number.parseInt(bitsAttr, 10),
-    };
-};
+const fieldFromNode = (node: RawNode, context: ParseContext): GirField => ({
+    name: nameAttr(node),
+    doc: getDoc(node),
+    type: typeRefFromNode(node, context),
+    cType: attr(getChild(node, "type"), "c:type"),
+    readable: isAttrTrue(node, "readable", true),
+    writable: isAttrTrue(node, "writable", false),
+    private: isAttrTrue(node, "private", false),
+    bits: intAttr(node, "bits"),
+    inlineMembers: undefined,
+    inlineIsUnion: false,
+});
+
+// A record may embed an anonymous `<union>` or `<record>` instead of naming a type for it. The
+// member occupies a real slot and contributes its own size and alignment, but carries no `<type>`,
+// so it has to be admitted as a field whose layout comes from its own children.
+const anonymousMemberFromNode = (node: RawNode, isUnion: boolean, context: ParseContext): GirField => ({
+    name: nameAttr(node),
+    doc: getDoc(node),
+    type: undefined,
+    cType: undefined,
+    readable: false,
+    writable: false,
+    private: true,
+    bits: undefined,
+    inlineMembers: collectFields(node, context),
+    inlineIsUnion: isUnion,
+});
+
+const collectFields = (node: RawNode, context: ParseContext): GirField[] => [
+    ...getChildren(node, "field").map((field) => fieldFromNode(field, context)),
+    ...getChildren(node, "union").map((member) => anonymousMemberFromNode(member, true, context)),
+    ...getChildren(node, "record").map((member) => anonymousMemberFromNode(member, false, context)),
+];
+
+export { collectFields, fieldFromNode, type GirField };