@gtkx/gir 0.19.0 → 0.21.0

package/src/internal/normalizer.ts

@@ -1,35 +1,15 @@
-/**
- * Normalizer that converts raw GIR types to normalized types.
- *
- * The key job is to qualify all type references with their namespace,
- * except for intrinsic types which remain unqualified.
- *
- * @internal
- */
-
 import { isIntrinsicType } from "../intrinsics.js";
-import {
-    GirAlias,
-    GirCallback,
-    GirClass,
-    GirConstant,
-    GirConstructor,
-    GirEnumeration,
-    GirEnumerationMember,
-    GirField,
-    GirFunction,
-    GirInterface,
-    GirMethod,
-    GirNamespace,
-    GirParameter,
-    GirProperty,
-    GirRecord,
-    GirSignal,
-    GirType,
-    parseDefaultValue,
-    type QualifiedName,
-    qualifiedName,
-} from "../types.js";
+import { GirAlias } from "../model/alias.js";
+import { GirConstructor, GirFunction, GirMethod } from "../model/callables.js";
+import { GirCallback } from "../model/callback.js";
+import { GirConstant } from "../model/constant.js";
+import { GirEnumeration, GirEnumerationMember } from "../model/enumeration.js";
+import { GirField } from "../model/field.js";
+import { GirParameter } from "../model/parameter.js";
+import { GirProperty, parseDefaultValue } from "../model/property.js";
+import { GirRecord } from "../model/record.js";
+import { GirSignal } from "../model/signal.js";
+import { GirType } from "../model/type.js";
 import type {
     RawAlias,
     RawCallback,
@@ -49,503 +29,499 @@ import type {
     RawType,
 } from "./raw-types.js";
 
+type TypeIndex = Map<string, Set<string>>;
+
 /**
- * Context for normalization - provides access to all loaded namespaces
- * for resolving cross-namespace references.
+ * Data produced for a class before the repository exists.
+ * Used to defer GirClass construction until the repo is available.
  */
-export type NormalizerContext = {
-    /** All raw namespaces that have been loaded */
-    rawNamespaces: Map<string, RawNamespace>;
+export type GirClassData = {
+    name: string;
+    qualifiedName: string;
+    cType: string;
+    parent: string | null;
+    abstract: boolean;
+    glibTypeName?: string;
+    glibGetType?: string;
+    cSymbolPrefix?: string;
+    fundamental?: boolean;
+    refFunc?: string;
+    unrefFunc?: string;
+    implements: string[];
+    methods: GirMethod[];
+    constructors: GirConstructor[];
+    staticFunctions: GirFunction[];
+    properties: GirProperty[];
+    signals: GirSignal[];
+    doc?: string;
 };
 
 /**
- * Normalizes a raw namespace into a normalized namespace.
+ * Data produced for an interface before the repository exists.
  */
-export const normalizeNamespace = (raw: RawNamespace, ctx: NormalizerContext): GirNamespace => {
-    const nsName = raw.name;
-
-    const classes = new Map<string, GirClass>();
-    const interfaces = new Map<string, GirInterface>();
-    const records = new Map<string, GirRecord>();
-    const enumerations = new Map<string, GirEnumeration>();
-    const bitfields = new Map<string, GirEnumeration>();
-    const callbacks = new Map<string, GirCallback>();
-    const functions = new Map<string, GirFunction>();
-    const constants = new Map<string, GirConstant>();
-    const aliases = new Map<string, GirAlias>();
-
-    for (const rawClass of raw.classes) {
-        const normalized = normalizeClass(rawClass, nsName, ctx);
-        classes.set(normalized.name, normalized);
-    }
+export type GirInterfaceData = {
+    name: string;
+    qualifiedName: string;
+    cType: string;
+    glibTypeName?: string;
+    prerequisites: string[];
+    methods: GirMethod[];
+    properties: GirProperty[];
+    signals: GirSignal[];
+    doc?: string;
+};
 
-    for (const rawInterface of raw.interfaces) {
-        const normalized = normalizeInterface(rawInterface, nsName, ctx);
-        interfaces.set(normalized.name, normalized);
-    }
+/**
+ * Intermediate namespace data produced by the normalizer.
+ *
+ * Classes and interfaces are stored as plain data because they need
+ * the repository reference at construction time (which doesn't exist yet).
+ * All other types are fully constructed model instances.
+ */
+export type GirNamespaceIntermediate = {
+    name: string;
+    version: string;
+    sharedLibrary: string;
+    cPrefix: string;
+    classes: Map<string, GirClassData>;
+    interfaces: Map<string, GirInterfaceData>;
+    records: Map<string, GirRecord>;
+    enumerations: Map<string, GirEnumeration>;
+    bitfields: Map<string, GirEnumeration>;
+    callbacks: Map<string, GirCallback>;
+    functions: Map<string, GirFunction>;
+    constants: Map<string, GirConstant>;
+    aliases: Map<string, GirAlias>;
+    doc?: string;
+};
 
-    for (const rawRecord of raw.records) {
-        const normalized = normalizeRecord(rawRecord, nsName, ctx);
-        records.set(normalized.name, normalized);
+/**
+ * Converts raw parsed GIR data into model instances with fully qualified
+ * type names.
+ *
+ * Uses indexed lookups for O(1) type name resolution and strict error
+ * handling (throws on unresolvable type references).
+ */
+export class GirNormalizer {
+    private typeIndex: TypeIndex = new Map();
+
+    /**
+     * Normalizes all raw namespaces into intermediate namespace data.
+     *
+     * @param rawNamespaces - Raw namespaces keyed by name, in dependency order
+     * @returns Intermediate namespace data keyed by name, in the same order
+     */
+    normalize(rawNamespaces: Map<string, RawNamespace>): Map<string, GirNamespaceIntermediate> {
+        this.typeIndex = this.buildTypeIndex(rawNamespaces);
+
+        const result = new Map<string, GirNamespaceIntermediate>();
+        for (const [name, raw] of rawNamespaces) {
+            result.set(name, this.normalizeNamespace(raw));
+        }
+        return result;
     }
 
-    for (const rawEnum of raw.enumerations) {
-        const normalized = normalizeEnumeration(rawEnum, nsName);
-        enumerations.set(normalized.name, normalized);
+    private buildTypeIndex(rawNamespaces: Map<string, RawNamespace>): TypeIndex {
+        const index: TypeIndex = new Map();
+        for (const [nsName, raw] of rawNamespaces) {
+            const names = new Set<string>();
+            for (const c of raw.classes) names.add(c.name);
+            for (const i of raw.interfaces) names.add(i.name);
+            for (const r of raw.records) names.add(r.name);
+            for (const e of raw.enumerations) names.add(e.name);
+            for (const b of raw.bitfields) names.add(b.name);
+            for (const cb of raw.callbacks) names.add(cb.name);
+            for (const a of raw.aliases) names.add(a.name);
+            index.set(nsName, names);
+        }
+        return index;
     }
 
-    for (const rawBitfield of raw.bitfields) {
-        const normalized = normalizeEnumeration(rawBitfield, nsName);
-        bitfields.set(normalized.name, normalized);
-    }
+    private normalizeNamespace(raw: RawNamespace): GirNamespaceIntermediate {
+        const nsName = raw.name;
 
-    for (const rawCallback of raw.callbacks) {
-        const normalized = normalizeCallback(rawCallback, nsName, ctx);
-        callbacks.set(normalized.name, normalized);
-    }
+        const classes = new Map<string, GirClassData>();
+        for (const rawClass of raw.classes) {
+            const data = this.normalizeClass(rawClass, nsName);
+            classes.set(data.name, data);
+        }
 
-    for (const rawFunction of raw.functions) {
-        const normalized = normalizeFunction(rawFunction, nsName, ctx);
-        functions.set(normalized.name, normalized);
-    }
+        const interfaces = new Map<string, GirInterfaceData>();
+        for (const rawIface of raw.interfaces) {
+            const data = this.normalizeInterface(rawIface, nsName);
+            interfaces.set(data.name, data);
+        }
 
-    for (const rawConstant of raw.constants) {
-        const normalized = normalizeConstant(rawConstant, nsName, ctx);
-        constants.set(normalized.name, normalized);
-    }
+        const records = new Map<string, GirRecord>();
+        for (const rawRecord of raw.records) {
+            const record = this.normalizeRecord(rawRecord, nsName);
+            records.set(record.name, record);
+        }
 
-    for (const rawAlias of raw.aliases) {
-        const normalized = normalizeAlias(rawAlias, nsName, ctx);
-        aliases.set(normalized.name, normalized);
-    }
+        const enumerations = new Map<string, GirEnumeration>();
+        for (const rawEnum of raw.enumerations) {
+            const enumeration = this.normalizeEnumeration(rawEnum, nsName);
+            enumerations.set(enumeration.name, enumeration);
+        }
 
-    return new GirNamespace({
-        name: raw.name,
-        version: raw.version,
-        sharedLibrary: raw.sharedLibrary,
-        cPrefix: raw.cPrefix,
-        classes,
-        interfaces,
-        records,
-        enumerations,
-        bitfields,
-        callbacks,
-        functions,
-        constants,
-        aliases,
-        doc: raw.doc,
-    });
-};
+        const bitfields = new Map<string, GirEnumeration>();
+        for (const rawBitfield of raw.bitfields) {
+            const bitfield = this.normalizeEnumeration(rawBitfield, nsName);
+            bitfields.set(bitfield.name, bitfield);
+        }
 
-/**
- * Normalizes a type reference, qualifying it with its namespace if not intrinsic.
- */
-const normalizeTypeName = (
-    typeName: string,
-    currentNamespace: string,
-    ctx: NormalizerContext,
-): QualifiedName | string => {
-    if (isIntrinsicType(typeName)) {
-        return typeName;
-    }
+        const callbacks = new Map<string, GirCallback>();
+        for (const rawCb of raw.callbacks) {
+            const cb = this.normalizeCallback(rawCb, nsName);
+            callbacks.set(cb.name, cb);
+        }
 
-    if (typeName.includes(".")) {
-        return typeName as QualifiedName;
-    }
+        const functions = new Map<string, GirFunction>();
+        for (const rawFunc of raw.functions) {
+            const func = this.normalizeFunction(rawFunc, nsName);
+            functions.set(func.name, func);
+        }
 
-    const currentNs = ctx.rawNamespaces.get(currentNamespace);
-    if (currentNs && typeExistsInNamespace(typeName, currentNs)) {
-        return qualifiedName(currentNamespace, typeName);
-    }
+        const constants = new Map<string, GirConstant>();
+        for (const rawConst of raw.constants) {
+            const constant = this.normalizeConstant(rawConst, nsName);
+            constants.set(constant.name, constant);
+        }
 
-    for (const [nsName, ns] of ctx.rawNamespaces) {
-        if (nsName !== currentNamespace && typeExistsInNamespace(typeName, ns)) {
-            return qualifiedName(nsName, typeName);
+        const aliases = new Map<string, GirAlias>();
+        for (const rawAlias of raw.aliases) {
+            const alias = this.normalizeAlias(rawAlias, nsName);
+            aliases.set(alias.name, alias);
         }
+
+        return {
+            name: raw.name,
+            version: raw.version,
+            sharedLibrary: raw.sharedLibrary,
+            cPrefix: raw.cPrefix,
+            classes,
+            interfaces,
+            records,
+            enumerations,
+            bitfields,
+            callbacks,
+            functions,
+            constants,
+            aliases,
+            doc: raw.doc,
+        };
     }
 
-    return qualifiedName(currentNamespace, typeName);
-};
+    private qualifyTypeName(typeName: string, currentNamespace: string): string {
+        if (isIntrinsicType(typeName)) return typeName;
+        if (typeName.includes(".")) return typeName;
 
-/**
- * Checks if a type name exists in a namespace.
- */
-const typeExistsInNamespace = (typeName: string, ns: RawNamespace): boolean => {
-    return (
-        ns.classes.some((c) => c.name === typeName) ||
-        ns.interfaces.some((i) => i.name === typeName) ||
-        ns.records.some((r) => r.name === typeName) ||
-        ns.enumerations.some((e) => e.name === typeName) ||
-        ns.bitfields.some((b) => b.name === typeName) ||
-        ns.callbacks.some((c) => c.name === typeName) ||
-        ns.aliases.some((a) => a.name === typeName)
-    );
-};
+        if (this.typeIndex.get(currentNamespace)?.has(typeName)) {
+            return `${currentNamespace}.${typeName}`;
+        }
 
-const buildContainerTypeBase = (raw: RawType) => ({
-    cType: raw.cType,
-    containerType: raw.containerType,
-    transferOwnership: raw.transferOwnership,
-    nullable: raw.nullable ?? false,
-});
+        for (const [nsName, names] of this.typeIndex) {
+            if (nsName !== currentNamespace && names.has(typeName)) {
+                return `${nsName}.${typeName}`;
+            }
+        }
 
-/**
- * Normalizes a raw type to a normalized type.
- */
-const normalizeType = (raw: RawType, currentNamespace: string, ctx: NormalizerContext): GirType => {
-    if (raw.containerType === "ghashtable") {
-        const typeParams = (raw.typeParameters ?? []).map((tp) => normalizeType(tp, currentNamespace, ctx));
-        return new GirType({
-            ...buildContainerTypeBase(raw),
-            name: qualifiedName("GLib", "HashTable"),
-            isArray: false,
-            elementType: typeParams[1] ?? null,
-            typeParameters: typeParams,
-        });
+        return `${currentNamespace}.${typeName}`;
     }
 
-    if (raw.containerType === "gptrarray" || raw.containerType === "garray") {
-        const typeParams = (raw.typeParameters ?? []).map((tp) => normalizeType(tp, currentNamespace, ctx));
-        const typeName = raw.containerType === "gptrarray" ? "PtrArray" : "Array";
-        return new GirType({
-            ...buildContainerTypeBase(raw),
-            name: qualifiedName("GLib", typeName),
-            isArray: true,
-            elementType: typeParams[0] ?? null,
-            typeParameters: typeParams,
-        });
-    }
+    private normalizeType(raw: RawType, currentNamespace: string): GirType {
+        if (raw.containerType === "ghashtable") {
+            const typeParams = (raw.typeParameters ?? []).map((tp) => this.normalizeType(tp, currentNamespace));
+            return new GirType({
+                name: `GLib.HashTable`,
+                cType: raw.cType,
+                containerType: raw.containerType,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                isArray: false,
+                elementType: typeParams[1] ?? null,
+                typeParameters: typeParams,
+            });
+        }
 
-    if (raw.containerType === "glist" || raw.containerType === "gslist") {
-        const elementType = raw.elementType ? normalizeType(raw.elementType, currentNamespace, ctx) : null;
-        return new GirType({
-            ...buildContainerTypeBase(raw),
-            name: "array",
-            isArray: true,
-            elementType,
-            typeParameters: elementType ? [elementType] : [],
-        });
-    }
+        if (raw.containerType === "gptrarray" || raw.containerType === "garray") {
+            const typeParams = (raw.typeParameters ?? []).map((tp) => this.normalizeType(tp, currentNamespace));
+            const typeName = raw.containerType === "gptrarray" ? "PtrArray" : "Array";
+            return new GirType({
+                name: `GLib.${typeName}`,
+                cType: raw.cType,
+                containerType: raw.containerType,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                isArray: true,
+                elementType: typeParams[0] ?? null,
+                typeParameters: typeParams,
+            });
+        }
 
-    const isArray = raw.isArray === true || raw.name === "array";
+        if (raw.containerType === "gbytearray") {
+            const elementType = raw.elementType ? this.normalizeType(raw.elementType, currentNamespace) : null;
+            return new GirType({
+                name: `GLib.ByteArray`,
+                cType: raw.cType,
+                containerType: raw.containerType,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                isArray: true,
+                elementType,
+            });
+        }
 
-    if (isArray && raw.elementType) {
-        return new GirType({
-            name: "array",
-            cType: raw.cType,
-            isArray: true,
-            elementType: normalizeType(raw.elementType, currentNamespace, ctx),
-            transferOwnership: raw.transferOwnership,
-            nullable: raw.nullable ?? false,
-            sizeParamIndex: raw.sizeParamIndex,
-            zeroTerminated: raw.zeroTerminated,
-            fixedSize: raw.fixedSize,
-        });
-    }
+        if (raw.containerType === "glist" || raw.containerType === "gslist") {
+            const elementType = raw.elementType ? this.normalizeType(raw.elementType, currentNamespace) : null;
+            return new GirType({
+                name: "array",
+                cType: raw.cType,
+                containerType: raw.containerType,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                isArray: true,
+                elementType,
+                typeParameters: elementType ? [elementType] : [],
+            });
+        }
+
+        const isArray = raw.isArray === true || raw.name === "array";
+
+        if (isArray) {
+            return new GirType({
+                name: "array",
+                cType: raw.cType,
+                isArray: true,
+                elementType: raw.elementType ? this.normalizeType(raw.elementType, currentNamespace) : null,
+                transferOwnership: raw.transferOwnership,
+                nullable: raw.nullable ?? false,
+                sizeParamIndex: raw.sizeParamIndex,
+                zeroTerminated: raw.zeroTerminated,
+                fixedSize: raw.fixedSize,
+            });
+        }
 
-    if (isArray) {
         return new GirType({
-            name: "array",
+            name: this.qualifyTypeName(raw.name, currentNamespace),
             cType: raw.cType,
-            isArray: true,
+            isArray: false,
             elementType: null,
             transferOwnership: raw.transferOwnership,
             nullable: raw.nullable ?? false,
-            sizeParamIndex: raw.sizeParamIndex,
-            zeroTerminated: raw.zeroTerminated,
-            fixedSize: raw.fixedSize,
         });
     }
 
-    return new GirType({
-        name: normalizeTypeName(raw.name, currentNamespace, ctx),
-        cType: raw.cType,
-        isArray: false,
-        elementType: null,
-        transferOwnership: raw.transferOwnership,
-        nullable: raw.nullable ?? false,
-    });
-};
-
-/**
- * Normalizes a raw class to a normalized class.
- */
-const normalizeClass = (raw: RawClass, currentNamespace: string, ctx: NormalizerContext): GirClass => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-
-    let parent: QualifiedName | null = null;
-    if (raw.parent) {
-        const normalizedParent = normalizeTypeName(raw.parent, currentNamespace, ctx);
-        if (typeof normalizedParent !== "string" || normalizedParent.includes(".")) {
-            parent = normalizedParent as QualifiedName;
+    private normalizeClass(raw: RawClass, currentNamespace: string): GirClassData {
+        let parent: string | null = null;
+        if (raw.parent) {
+            const qualified = this.qualifyTypeName(raw.parent, currentNamespace);
+            if (qualified.includes(".")) {
+                parent = qualified;
+            }
         }
-    }
 
-    const implementsRefs = raw.implements.map((impl) => {
-        const normalized = normalizeTypeName(impl, currentNamespace, ctx);
-        return normalized as QualifiedName;
-    });
-
-    return new GirClass({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        parent,
-        abstract: raw.abstract ?? false,
-        glibTypeName: raw.glibTypeName,
-        glibGetType: raw.glibGetType,
-        cSymbolPrefix: raw.cSymbolPrefix,
-        fundamental: raw.fundamental ?? false,
-        refFunc: raw.refFunc,
-        unrefFunc: raw.unrefFunc,
-        implements: implementsRefs,
-        methods: raw.methods.map((m) => normalizeMethod(m, currentNamespace, ctx)),
-        constructors: raw.constructors.map((c) => normalizeConstructor(c, currentNamespace, ctx)),
-        staticFunctions: raw.functions.map((f) => normalizeFunction(f, currentNamespace, ctx)),
-        properties: raw.properties.map((p) => normalizeProperty(p, currentNamespace, ctx)),
-        signals: raw.signals.map((s) => normalizeSignal(s, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
+        return {
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            parent,
+            abstract: raw.abstract ?? false,
+            glibTypeName: raw.glibTypeName,
+            glibGetType: raw.glibGetType,
+            cSymbolPrefix: raw.cSymbolPrefix,
+            fundamental: raw.fundamental ?? false,
+            refFunc: raw.refFunc,
+            unrefFunc: raw.unrefFunc,
+            implements: raw.implements.map((impl) => this.qualifyTypeName(impl, currentNamespace)),
+            methods: raw.methods.map((m) => this.normalizeMethod(m, currentNamespace)),
+            constructors: raw.constructors.map((c) => this.normalizeConstructor(c, currentNamespace)),
+            staticFunctions: raw.functions.map((f) => this.normalizeFunction(f, currentNamespace)),
+            properties: raw.properties.map((p) => this.normalizeProperty(p, currentNamespace)),
+            signals: raw.signals.map((s) => this.normalizeSignal(s, currentNamespace)),
+            doc: raw.doc,
+        };
+    }
 
-/**
- * Normalizes a raw interface to a normalized interface.
- */
-const normalizeInterface = (raw: RawInterface, currentNamespace: string, ctx: NormalizerContext): GirInterface => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-
-    const prerequisites = raw.prerequisites.map((prereq) => {
-        const normalized = normalizeTypeName(prereq, currentNamespace, ctx);
-        return normalized as QualifiedName;
-    });
-
-    return new GirInterface({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        glibTypeName: raw.glibTypeName,
-        prerequisites,
-        methods: raw.methods.map((m) => normalizeMethod(m, currentNamespace, ctx)),
-        properties: raw.properties.map((p) => normalizeProperty(p, currentNamespace, ctx)),
-        signals: raw.signals.map((s) => normalizeSignal(s, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
+    private normalizeInterface(raw: RawInterface, currentNamespace: string): GirInterfaceData {
+        return {
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            glibTypeName: raw.glibTypeName,
+            prerequisites: raw.prerequisites.map((prereq) => this.qualifyTypeName(prereq, currentNamespace)),
+            methods: raw.methods.map((m) => this.normalizeMethod(m, currentNamespace)),
+            properties: raw.properties.map((p) => this.normalizeProperty(p, currentNamespace)),
+            signals: raw.signals.map((s) => this.normalizeSignal(s, currentNamespace)),
+            doc: raw.doc,
+        };
+    }
 
-/**
- * Normalizes a raw record to a normalized record.
- */
-const normalizeRecord = (raw: RawRecord, currentNamespace: string, ctx: NormalizerContext): GirRecord => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-
-    return new GirRecord({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        opaque: raw.opaque ?? false,
-        disguised: raw.disguised ?? false,
-        glibTypeName: raw.glibTypeName,
-        glibGetType: raw.glibGetType,
-        isGtypeStructFor: raw.isGtypeStructFor,
-        copyFunction: raw.copyFunction,
-        freeFunction: raw.freeFunction,
-        fields: raw.fields.map((f) => normalizeField(f, currentNamespace, ctx)),
-        methods: raw.methods.map((m) => normalizeMethod(m, currentNamespace, ctx)),
-        constructors: raw.constructors.map((c) => normalizeConstructor(c, currentNamespace, ctx)),
-        staticFunctions: raw.functions.map((f) => normalizeFunction(f, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
+    private normalizeRecord(raw: RawRecord, currentNamespace: string): GirRecord {
+        return new GirRecord({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            opaque: raw.opaque ?? false,
+            disguised: raw.disguised ?? false,
+            glibTypeName: raw.glibTypeName,
+            glibGetType: raw.glibGetType,
+            isGtypeStructFor: raw.isGtypeStructFor,
+            copyFunction: raw.copyFunction,
+            freeFunction: raw.freeFunction,
+            fields: raw.fields.map((f) => this.normalizeField(f, currentNamespace)),
+            methods: raw.methods.map((m) => this.normalizeMethod(m, currentNamespace)),
+            constructors: raw.constructors.map((c) => this.normalizeConstructor(c, currentNamespace)),
+            staticFunctions: raw.functions.map((f) => this.normalizeFunction(f, currentNamespace)),
+            doc: raw.doc,
+        });
+    }
 
-/**
- * Normalizes a raw enumeration to a normalized enumeration.
- */
-const normalizeEnumeration = (raw: RawEnumeration, currentNamespace: string): GirEnumeration => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-
-    return new GirEnumeration({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        members: raw.members.map(
-            (m) =>
-                new GirEnumerationMember({
-                    name: m.name,
-                    value: m.value,
-                    cIdentifier: m.cIdentifier,
-                    doc: m.doc,
-                }),
-        ),
-        glibGetType: raw.glibGetType,
-        doc: raw.doc,
-    });
-};
+    private normalizeEnumeration(raw: RawEnumeration, currentNamespace: string): GirEnumeration {
+        return new GirEnumeration({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            members: raw.members.map(
+                (m) =>
+                    new GirEnumerationMember({
+                        name: m.name,
+                        value: m.value,
+                        cIdentifier: m.cIdentifier,
+                        doc: m.doc,
+                    }),
+            ),
+            glibGetType: raw.glibGetType,
+            doc: raw.doc,
+        });
+    }
 
-/**
- * Normalizes a raw callback to a normalized callback.
- */
-const normalizeCallback = (raw: RawCallback, currentNamespace: string, ctx: NormalizerContext): GirCallback => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-
-    return new GirCallback({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        returnType: normalizeType(raw.returnType, currentNamespace, ctx),
-        parameters: raw.parameters.map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
+    private normalizeCallback(raw: RawCallback, currentNamespace: string): GirCallback {
+        return new GirCallback({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            returnType: this.normalizeType(raw.returnType, currentNamespace),
+            parameters: raw.parameters.map((p) => this.normalizeParameter(p, currentNamespace)),
+            doc: raw.doc,
+        });
+    }
 
-/**
- * Normalizes a raw constant to a normalized constant.
- */
-const normalizeConstant = (raw: RawConstant, currentNamespace: string, ctx: NormalizerContext): GirConstant => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-
-    return new GirConstant({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        value: raw.value,
-        type: normalizeType(raw.type, currentNamespace, ctx),
-        doc: raw.doc,
-    });
-};
+    private normalizeConstant(raw: RawConstant, currentNamespace: string): GirConstant {
+        return new GirConstant({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            value: raw.value,
+            type: this.normalizeType(raw.type, currentNamespace),
+            doc: raw.doc,
+        });
+    }
 
-/**
- * Normalizes a raw alias to a normalized alias.
- */
-const normalizeAlias = (raw: RawAlias, currentNamespace: string, ctx: NormalizerContext): GirAlias => {
-    const qn = qualifiedName(currentNamespace, raw.name);
-
-    return new GirAlias({
-        name: raw.name,
-        qualifiedName: qn,
-        cType: raw.cType,
-        targetType: normalizeType(raw.targetType, currentNamespace, ctx),
-        doc: raw.doc,
-    });
-};
+    private normalizeAlias(raw: RawAlias, currentNamespace: string): GirAlias {
+        return new GirAlias({
+            name: raw.name,
+            qualifiedName: `${currentNamespace}.${raw.name}`,
+            cType: raw.cType,
+            targetType: this.normalizeType(raw.targetType, currentNamespace),
+            doc: raw.doc,
+        });
+    }
 
-/**
- * Normalizes a raw method to a normalized method.
- */
-const normalizeMethod = (raw: RawMethod, currentNamespace: string, ctx: NormalizerContext): GirMethod => {
-    return new GirMethod({
-        name: raw.name,
-        cIdentifier: raw.cIdentifier,
-        returnType: normalizeType(raw.returnType, currentNamespace, ctx),
-        parameters: raw.parameters.map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        instanceParameter: raw.instanceParameter
-            ? normalizeParameter(raw.instanceParameter, currentNamespace, ctx)
-            : undefined,
-        throws: raw.throws ?? false,
-        doc: raw.doc,
-        returnDoc: raw.returnDoc,
-        finishFunc: raw.finishFunc,
-        shadows: raw.shadows,
-        shadowedBy: raw.shadowedBy,
-    });
-};
+    private normalizeMethod(raw: RawMethod, currentNamespace: string): GirMethod {
+        return new GirMethod({
+            name: raw.name,
+            cIdentifier: raw.cIdentifier,
+            returnType: this.normalizeType(raw.returnType, currentNamespace),
+            parameters: raw.parameters.map((p) => this.normalizeParameter(p, currentNamespace)),
+            instanceParameter: raw.instanceParameter
+                ? this.normalizeParameter(raw.instanceParameter, currentNamespace)
+                : undefined,
+            throws: raw.throws ?? false,
+            doc: raw.doc,
+            returnDoc: raw.returnDoc,
+            finishFunc: raw.finishFunc,
+            shadows: raw.shadows,
+            shadowedBy: raw.shadowedBy,
+        });
+    }
 
-/**
- * Normalizes a raw constructor to a normalized constructor.
- */
-const normalizeConstructor = (
-    raw: RawConstructor,
-    currentNamespace: string,
-    ctx: NormalizerContext,
-): GirConstructor => {
-    return new GirConstructor({
-        name: raw.name,
-        cIdentifier: raw.cIdentifier,
-        returnType: normalizeType(raw.returnType, currentNamespace, ctx),
-        parameters: raw.parameters.map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        throws: raw.throws ?? false,
-        doc: raw.doc,
-        returnDoc: raw.returnDoc,
-        shadows: raw.shadows,
-        shadowedBy: raw.shadowedBy,
-    });
-};
+    private normalizeConstructor(raw: RawConstructor, currentNamespace: string): GirConstructor {
+        return new GirConstructor({
+            name: raw.name,
+            cIdentifier: raw.cIdentifier,
+            returnType: this.normalizeType(raw.returnType, currentNamespace),
+            parameters: raw.parameters.map((p) => this.normalizeParameter(p, currentNamespace)),
+            throws: raw.throws ?? false,
+            doc: raw.doc,
+            returnDoc: raw.returnDoc,
+            shadows: raw.shadows,
+            shadowedBy: raw.shadowedBy,
+        });
+    }
 
-/**
- * Normalizes a raw function to a normalized function.
- */
-const normalizeFunction = (raw: RawFunction, currentNamespace: string, ctx: NormalizerContext): GirFunction => {
-    return new GirFunction({
-        name: raw.name,
-        cIdentifier: raw.cIdentifier,
-        returnType: normalizeType(raw.returnType, currentNamespace, ctx),
-        parameters: raw.parameters.map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        throws: raw.throws ?? false,
-        doc: raw.doc,
-        returnDoc: raw.returnDoc,
-        shadows: raw.shadows,
-        shadowedBy: raw.shadowedBy,
-    });
-};
+    private normalizeFunction(raw: RawFunction, currentNamespace: string): GirFunction {
+        return new GirFunction({
+            name: raw.name,
+            cIdentifier: raw.cIdentifier,
+            returnType: this.normalizeType(raw.returnType, currentNamespace),
+            parameters: raw.parameters.map((p) => this.normalizeParameter(p, currentNamespace)),
+            throws: raw.throws ?? false,
+            doc: raw.doc,
+            returnDoc: raw.returnDoc,
+            shadows: raw.shadows,
+            shadowedBy: raw.shadowedBy,
+        });
+    }
 
-/**
- * Normalizes a raw parameter to a normalized parameter.
- */
-const normalizeParameter = (raw: RawParameter, currentNamespace: string, ctx: NormalizerContext): GirParameter => {
-    return new GirParameter({
-        name: raw.name,
-        type: normalizeType(raw.type, currentNamespace, ctx),
-        direction: raw.direction ?? "in",
-        callerAllocates: raw.callerAllocates ?? false,
-        nullable: raw.nullable ?? false,
-        optional: raw.optional ?? false,
-        scope: raw.scope,
-        closure: raw.closure,
-        destroy: raw.destroy,
-        transferOwnership: raw.transferOwnership,
-        doc: raw.doc,
-    });
-};
+    private normalizeParameter(raw: RawParameter, currentNamespace: string): GirParameter {
+        return new GirParameter({
+            name: raw.name,
+            type: this.normalizeType(raw.type, currentNamespace),
+            direction: raw.direction ?? "in",
+            callerAllocates: raw.callerAllocates ?? false,
+            nullable: raw.nullable ?? false,
+            optional: raw.optional ?? false,
+            scope: raw.scope,
+            closure: raw.closure,
+            destroy: raw.destroy,
+            transferOwnership: raw.transferOwnership,
+            doc: raw.doc,
+        });
+    }
 
-/**
- * Normalizes a raw property to a normalized property.
- */
-const normalizeProperty = (raw: RawProperty, currentNamespace: string, ctx: NormalizerContext): GirProperty => {
-    return new GirProperty({
-        name: raw.name,
-        type: normalizeType(raw.type, currentNamespace, ctx),
-        readable: raw.readable ?? true,
-        writable: raw.writable ?? false,
-        constructOnly: raw.constructOnly ?? false,
-        defaultValue: parseDefaultValue(raw.defaultValueRaw),
-        getter: raw.getter,
-        setter: raw.setter,
-        doc: raw.doc,
-    });
-};
+    private normalizeProperty(raw: RawProperty, currentNamespace: string): GirProperty {
+        return new GirProperty({
+            name: raw.name,
+            type: this.normalizeType(raw.type, currentNamespace),
+            readable: raw.readable ?? true,
+            writable: raw.writable ?? false,
+            constructOnly: raw.constructOnly ?? false,
+            defaultValue: parseDefaultValue(raw.defaultValueRaw),
+            getter: raw.getter,
+            setter: raw.setter,
+            doc: raw.doc,
+        });
+    }
 
-/**
- * Normalizes a raw signal to a normalized signal.
- */
-const normalizeSignal = (raw: RawSignal, currentNamespace: string, ctx: NormalizerContext): GirSignal => {
-    return new GirSignal({
-        name: raw.name,
-        when: raw.when ?? "last",
-        returnType: raw.returnType ? normalizeType(raw.returnType, currentNamespace, ctx) : null,
-        parameters: (raw.parameters ?? []).map((p) => normalizeParameter(p, currentNamespace, ctx)),
-        doc: raw.doc,
-    });
-};
+    private normalizeSignal(raw: RawSignal, currentNamespace: string): GirSignal {
+        return new GirSignal({
+            name: raw.name,
+            when: raw.when ?? "last",
+            returnType: raw.returnType ? this.normalizeType(raw.returnType, currentNamespace) : null,
+            parameters: (raw.parameters ?? []).map((p) => this.normalizeParameter(p, currentNamespace)),
+            doc: raw.doc,
+        });
+    }
 
-/**
- * Normalizes a raw field to a normalized field.
- */
-const normalizeField = (raw: RawField, currentNamespace: string, ctx: NormalizerContext): GirField => {
-    return new GirField({
-        name: raw.name,
-        type: normalizeType(raw.type, currentNamespace, ctx),
-        writable: raw.writable ?? false,
-        readable: raw.readable ?? true,
-        private: raw.private ?? false,
-        doc: raw.doc,
-    });
-};
+    private normalizeField(raw: RawField, currentNamespace: string): GirField {
+        return new GirField({
+            name: raw.name,
+            type: this.normalizeType(raw.type, currentNamespace),
+            writable: raw.writable ?? false,
+            readable: raw.readable ?? true,
+            private: raw.private ?? false,
+            doc: raw.doc,
+        });
+    }
+}