@gtkx/codegen 1.0.0-rc.4 → 1.1.0

package/src/store/gi/vtable.ts

@@ -1,46 +1,116 @@
-import { pascalCase, sourceStringLiteral, toCamelIdentifier } from "@gtkx/utils";
-import type { GirCallback } from "../../gir/callback.js";
-import type { GirClass } from "../../gir/class.js";
+import { pascalCase, sanitizeTypeIdentifier, sourceStringLiteral } from "@gtkx/utils";
+import type { GirClass, GirVirtualMethod } from "../../gir/class.js";
 import type { GirField } from "../../gir/field.js";
+import type { GirFunction } from "../../gir/function.js";
+import type { Library } from "../../gir/library.js";
 import type { GirParameter } from "../../gir/parameter.js";
+import type { GirRecord } from "../../gir/record.js";
+import type { TypeId } from "../../gir/type-id.js";
 import type { ModuleContext } from "../../writer/context.js";
+import type { JsDocSpec } from "../../writer/doc.js";
 import {
     isInlineCallbackRef,
     isScalarRef,
     renderDescriptor,
     renderParamDescriptor,
 } from "../../analysis/descriptor-render.js";
-import { renderBraced } from "../../writer/emit.js";
+import {
+    foldedLengthParameters,
+    handlerParameters,
+    parameterIdentifier,
+    renamesWithInstance,
+    renderHandlerParameters,
+    renderHandlerResultType,
+} from "../../analysis/param-structure.js";
+import { renderTsType } from "../../analysis/ts-type.js";
+import { typeKey } from "../../analysis/type-key.js";
+import { ancestorChain, type ResolvedAncestor, resolveInterfaces } from "../../gir/ancestry.js";
+import { callbackAsFunction, type GirCallback } from "../../gir/callback.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { renderBlock, renderBraced } from "../../writer/emit.js";
+import { handlerSpec, THROWS_TEXT } from "./doc-spec.js";
 import { computeRecordFieldSlots } from "./record-layout.js";
 
 type VtableKind = "class" | "interface";
+type VfuncMemberMode = "implementation" | "requirement" | "signature";
 
-type RenderVtableSlotDescriptorOptions = {
+type VtableSlot = {
     key: string;
-    structName: string;
-    kind: VtableKind;
     field: GirField;
     callback: GirCallback;
+    vfunc: GirVirtualMethod | undefined;
     byteOffset: number;
-    vtableSize: number;
 };
 
-const renderVfuncMetadata = (context: ModuleContext, klass: GirClass): string | undefined => {
-    if (klass.glibTypeStruct === undefined) {
-        return undefined;
-    }
+type VfuncMemberOptions = {
+    context: ModuleContext;
+    ownerRef: string;
+    slot: VtableSlot;
+    mode: VfuncMemberMode;
+    isProtected: boolean;
+};
 
-    const structName = pascalCase(klass.glibTypeStruct);
-    const kind: VtableKind = klass.isInterface ? "interface" : "class";
-    const entries = vtableEntries(context, structName, kind, klass.glibTypeStruct);
+type VfuncMembersOptions = {
+    context: ModuleContext;
+    klass: GirClass;
+    mode: VfuncMemberMode;
+};
 
-    if (entries.length === 0) {
-        return undefined;
-    }
+type VfuncSignature = {
+    header: string;
+    returnType: string;
+};
 
-    return renderBraced(entries.join("\n"));
+type VfuncEntry = {
+    name: string;
+    signature: string;
+    doc: string | undefined;
 };
 
+type Vtable = {
+    structName: string;
+    kind: VtableKind;
+    vtableSize: number;
+    slots: VtableSlot[];
+};
+
+const PADDING_FIELD_NAME = /^(?:reserved|padding)\d*$/i;
+
+const UNCALLABLE_SLOT_KEYS: Set<string> = new Set([
+    "vfuncDispose",
+    "vfuncFinalize",
+    "vfuncGetProperty",
+    "vfuncSetProperty",
+]);
+
+const VTABLE_CACHE: WeakMap<GirClass, Vtable> = new WeakMap();
+const PROTECTED_SLOT_NOTE = "It is `protected`, so only a subclass chaining up reaches it.";
+const PUBLIC_SLOT_NOTE = "Calling it from anywhere else re-enters the slot on a live instance.";
+
+const vfuncMemberName = (fieldName: string): string => `vfunc${pascalCase(fieldName)}`;
+
+const vfuncOverrideNote = (slot: VtableSlot, isProtected: boolean): string =>
+    [
+        `Invokes the \`${slot.field.name}\` vtable slot. Override it on a class passed to \`registerClass\``,
+        `and chain up with \`super.${slot.key}()\`.`,
+        isProtected ? PROTECTED_SLOT_NOTE : PUBLIC_SLOT_NOTE,
+    ].join("\n");
+
+const vfuncRequirementNote = (slot: VtableSlot, ownerRef: string): string =>
+    [
+        `Fills the \`${slot.field.name}\` vtable slot. Declare it on a class passed to \`registerClass\``,
+        `with \`${ownerRef}\` in \`implements\`, which installs it in the interface vtable. Leaving it out`,
+        "keeps whatever the interface installs by default, the way it does for a C implementer.",
+    ].join("\n");
+
+const vfuncMemberNote = (options: VfuncMemberOptions): string =>
+    options.mode === "requirement"
+        ? vfuncRequirementNote(options.slot, options.ownerRef)
+        : vfuncOverrideNote(options.slot, options.isProtected);
+
+const isPaddingField = (field: GirField): boolean =>
+    field.name.startsWith("_") || PADDING_FIELD_NAME.test(field.name);
+
 const vtableCallbackType = (context: ModuleContext, field: GirField): GirCallback | undefined => {
     if (field.type === undefined) {
         return undefined;
@@ -60,15 +130,19 @@ const vtableSlotEntry = (
     field: GirField,
     claimedNames: Set<string>,
 ): { key: string; callback: GirCallback } | undefined => {
+    if (field.name === "constructor" || isPaddingField(field)) {
+        return undefined;
+    }
+
     const callback = vtableCallbackType(context, field);
 
     if (callback === undefined) {
         return undefined;
     }
 
-    const key = toCamelIdentifier(field.name);
+    const key = vfuncMemberName(field.name);
 
-    if (key === "constructor" || claimedNames.has(key)) {
+    if (claimedNames.has(key)) {
         return undefined;
     }
 
@@ -79,53 +153,342 @@ const vtableSlotEntry = (
     return { key, callback };
 };
 
-const vtableEntries = (context: ModuleContext, structName: string, kind: VtableKind, typeStruct: string): string[] => {
-    const resolved = context.library.resolveType(context.namespace.name, typeStruct);
-
-    if (resolved?.kind !== "record") {
-        return [];
-    }
-
-    const { slots, size } = computeRecordFieldSlots(context, resolved.value.fields, resolved.value.isUnion);
-    const entries: string[] = [];
+const collectVtableSlots = (
+    context: ModuleContext,
+    fields: GirField[],
+    isUnion: boolean,
+): { slots: VtableSlot[]; vtableSize: number } => {
+    const { slots, size } = computeRecordFieldSlots(context, fields, isUnion);
+    const entries: VtableSlot[] = [];
     const claimedNames: Set<string> = new Set();
 
     for (const { field, slot } of slots) {
         const entry = vtableSlotEntry(context, field, claimedNames);
 
-        if (entry === undefined) {
-            continue;
+        if (entry !== undefined) {
+            claimedNames.add(entry.key);
+            entries.push({ ...entry, field, vfunc: undefined, byteOffset: slot.byteOffset });
         }
+    }
+
+    return { slots: entries, vtableSize: size };
+};
 
-        claimedNames.add(entry.key);
+const resolveVtableRecord = (
+    context: ModuleContext,
+    namespaceName: string,
+    klass: GirClass,
+): { typeStruct: string; record: GirRecord } | undefined => {
+    const typeStruct = klass.glibTypeStruct;
+    const resolved = typeStruct === undefined ? undefined : context.library.resolveType(namespaceName, typeStruct);
 
-        entries.push(
-            renderVtableSlotDescriptor(context, {
-                key: entry.key,
-                structName,
-                kind,
-                field,
-                callback: entry.callback,
-                byteOffset: slot.byteOffset,
-                vtableSize: size,
-            }),
-        );
+    if (typeStruct === undefined || resolved?.kind !== "record" || resolved.value.fields.length === 0) {
+        return undefined;
     }
 
-    return entries;
+    return { typeStruct, record: resolved.value };
 };
 
-const isUnsupportedOutParam = (context: ModuleContext, param: GirParameter): boolean =>
-    (param.direction === "out" || param.direction === "inout") &&
-    !param.callerAllocates &&
-    !isScalarRef(context.library, param.type);
+const attachVirtualMethods = (slots: VtableSlot[], klass: GirClass): VtableSlot[] => {
+    const byKey: Map<string, GirVirtualMethod> = new Map(
+        klass.vfuncs.map((vfunc) => [vfuncMemberName(vfunc.name), vfunc]),
+    );
 
-const isEligibleVtableParam = (context: ModuleContext, param: GirParameter): boolean => {
-    if (param.isVarargs) {
-        return false;
+    return slots.map((slot) => ({ ...slot, vfunc: byKey.get(slot.key) }));
+};
+
+const buildVtable = (context: ModuleContext, namespaceName: string, klass: GirClass): Vtable | undefined => {
+    const resolved = resolveVtableRecord(context, namespaceName, klass);
+
+    if (resolved === undefined) {
+        return undefined;
+    }
+
+    const { slots, vtableSize } = collectVtableSlots(context, resolved.record.fields, resolved.record.isUnion);
+
+    if (slots.length === 0) {
+        return undefined;
+    }
+
+    return {
+        structName: pascalCase(resolved.typeStruct),
+        kind: klass.isInterface ? "interface" : "class",
+        vtableSize,
+        slots: disambiguateSlots(context, namespaceName, klass, attachVirtualMethods(slots, klass)),
+    };
+};
+
+const collectVtable = (context: ModuleContext, namespaceName: string, klass: GirClass): Vtable | undefined => {
+    const cached = VTABLE_CACHE.get(klass);
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const vtable = buildVtable(context, namespaceName, klass);
+
+    if (vtable !== undefined) {
+        VTABLE_CACHE.set(klass, vtable);
     }
 
-    if (isUnsupportedOutParam(context, param)) {
+    return vtable;
+};
+
+const shadowedSlotKey = (klass: GirClass, slot: VtableSlot): string =>
+    `vfunc${sanitizeTypeIdentifier(klass.name)}${pascalCase(slot.field.name)}`;
+
+const slotSignatureKey = (library: Library, slot: VtableSlot): string => {
+    const [, ...parameters] = slot.callback.parameters;
+
+    const parts = parameters.map(
+        (parameter) => `${typeKey(library, parameter.type)}/${parameter.direction}/${String(parameter.nullable)}`);
+
+    return `${parts.join(",")}->${typeKey(library, slot.callback.returnValue.type)}`;
+};
+
+const isShadowingSlot = (library: Library, slot: VtableSlot, inherited: VtableSlot[]): boolean =>
+    inherited.some(
+        (other) =>
+            other.key === slot.key &&
+            slotIdentity(other) !== slotIdentity(slot) &&
+            slotSignatureKey(library, other) !== slotSignatureKey(library, slot));
+
+const disambiguateSlots = (
+    context: ModuleContext,
+    namespaceName: string,
+    klass: GirClass,
+    slots: VtableSlot[],
+): VtableSlot[] => {
+    const inherited = ancestorSlots(context, namespaceName, klass);
+
+    return slots.map((slot) =>
+        isShadowingSlot(context.library, slot, inherited) ? { ...slot, key: shadowedSlotKey(klass, slot) } : slot);
+};
+
+const ancestorSlots = (context: ModuleContext, namespaceName: string, klass: GirClass): VtableSlot[] => {
+    const [, ...ancestors] = [...ancestorChain(context.library, klass, namespaceName)];
+
+    return ancestors.flatMap((ancestor) => collectVtable(context, ancestor.namespaceName, ancestor.klass)?.slots ?? []);
+};
+
+const vfuncMemberNames = (context: ModuleContext, namespaceName: string, klass: GirClass): string[] =>
+    collectVtable(context, namespaceName, klass)?.slots.map((slot) => slot.key) ?? [];
+
+const renderVfuncMetadata = (context: ModuleContext, klass: GirClass): string | undefined => {
+    const vtable = collectVtable(context, context.namespace.name, klass);
+
+    if (vtable === undefined) {
+        return undefined;
+    }
+
+    const entries = vtable.slots.map((slot) => renderVtableSlotDescriptor(context, vtable, slot));
+
+    return renderBraced(entries.join("\n"));
+};
+
+const slotIdentity = (slot: VtableSlot): string => `${slot.key}:${String(slot.byteOffset)}`;
+
+const inheritedSlotIdentities = (context: ModuleContext, namespaceName: string, klass: GirClass): Set<string> =>
+    new Set(ancestorSlots(context, namespaceName, klass).map((slot) => slotIdentity(slot)));
+
+const addInterfaceSlotKeys = (
+    context: ModuleContext,
+    iface: ResolvedAncestor,
+    keys: Set<string>,
+    seen: Set<string>,
+): void => {
+    const identity = `${iface.namespaceName}.${iface.klass.name}`;
+
+    if (seen.has(identity)) {
+        return;
+    }
+
+    seen.add(identity);
+
+    for (const key of vfuncMemberNames(context, iface.namespaceName, iface.klass)) {
+        keys.add(key);
+    }
+
+    for (const ref of resolveInterfaces(context.library, iface.namespaceName, iface.klass.prerequisites)) {
+        addInterfaceSlotKeys(context, ref, keys, seen);
+    }
+};
+
+const implementedSlotKeys = (context: ModuleContext, namespaceName: string, klass: GirClass): Set<string> => {
+    const keys: Set<string> = new Set();
+    const seen: Set<string> = new Set();
+
+    for (const ancestor of ancestorChain(context.library, klass, namespaceName)) {
+        for (const ref of resolveInterfaces(context.library, ancestor.namespaceName, ancestor.klass.implements)) {
+            addInterfaceSlotKeys(context, ref, keys, seen);
+        }
+    }
+
+    return keys;
+};
+
+const protectedSlotKeys = (options: VfuncMembersOptions, slots: VtableSlot[]): Set<string> => {
+    const { context, klass } = options;
+
+    if (klass.isInterface) {
+        return new Set();
+    }
+
+    const shared = implementedSlotKeys(context, context.namespace.name, klass);
+
+    return new Set(slots.map((slot) => slot.key).filter((key) => !shared.has(key)));
+};
+
+const vfuncCallables = (context: ModuleContext, namespaceName: string, klass: GirClass): Map<string, GirFunction> => {
+    const members: Map<string, GirFunction> = new Map();
+
+    for (const slot of callableVfuncSlots(context, namespaceName, klass)) {
+        const [, ...parameters] = slot.callback.parameters;
+        members.set(slot.key, { ...callbackAsFunction(slot.callback), parameters });
+    }
+
+    return members;
+};
+
+const addProtectedSlotKeys = (context: ModuleContext, ancestor: ResolvedAncestor, keys: Set<string>): void => {
+    const shared = implementedSlotKeys(context, ancestor.namespaceName, ancestor.klass);
+
+    for (const slot of callableVfuncSlots(context, ancestor.namespaceName, ancestor.klass)) {
+        if (!shared.has(slot.key)) {
+            keys.add(slot.key);
+        }
+    }
+};
+
+const protectedChainSlotKeys = (context: ModuleContext, klass: GirClass): Set<string> => {
+    const keys: Set<string> = new Set();
+
+    for (const ancestor of ancestorChain(context.library, klass, context.namespace.name)) {
+        addProtectedSlotKeys(context, ancestor, keys);
+    }
+
+    return keys;
+};
+
+const callableVfuncSlots = (context: ModuleContext, namespaceName: string, klass: GirClass): VtableSlot[] => {
+    const vtable = collectVtable(context, namespaceName, klass);
+
+    if (vtable === undefined) {
+        return [];
+    }
+
+    const inherited = inheritedSlotIdentities(context, namespaceName, klass);
+
+    return vtable.slots.filter((slot) => isCallableSlot(context, slot) && !inherited.has(slotIdentity(slot)));
+};
+
+const hasCallableVfuncSlots = (context: ModuleContext, namespaceName: string, klass: GirClass): boolean =>
+    callableVfuncSlots(context, namespaceName, klass).length > 0;
+
+const slotDoc = (slot: VtableSlot): string | undefined => slot.vfunc?.doc ?? slot.field.doc ?? slot.callback.doc;
+
+const slotDocParameters = (slot: VtableSlot): GirParameter[] => {
+    const [, ...parameters] = slot.callback.parameters;
+    const vfuncParameters = slot.vfunc?.parameters ?? [];
+
+    return parameters.map((parameter, index) => ({ ...parameter, doc: vfuncParameters[index]?.doc ?? parameter.doc }));
+};
+
+const slotDocSpec = (slot: VtableSlot): JsDocSpec => {
+    const parameters = slotDocParameters(slot);
+    const source = slot.vfunc ?? slot.callback;
+
+    return {
+        ...handlerSpec(source, parameters, renamesWithInstance(parameters, slot.callback.parameters[0])),
+        returns: slot.vfunc?.returnValue.doc ?? slot.callback.returnValue.doc,
+        throws: slot.callback.throws ? THROWS_TEXT : undefined,
+    };
+};
+
+const vfuncEntries = (context: ModuleContext, namespaceName: string, klass: GirClass): VfuncEntry[] =>
+    callableVfuncSlots(context, namespaceName, klass).map((slot) => ({
+        name: slot.key,
+        signature: vfuncSlotSignature(context, slot).header,
+        doc: slotDoc(slot),
+    }));
+
+const renderVfuncMembers = (options: VfuncMembersOptions): string[] => {
+    const { context, klass, mode } = options;
+    const ownerRef = sanitizeTypeIdentifier(klass.name);
+    const slots = callableVfuncSlots(context, context.namespace.name, klass);
+
+    if (slots.length === 0) {
+        return [];
+    }
+
+    if (mode === "implementation") {
+        context.addRuntimeImport("callVfunc");
+    }
+
+    const protectedKeys = protectedSlotKeys(options, slots);
+
+    return slots.map((slot) =>
+        renderVfuncMember({ context, ownerRef, slot, mode, isProtected: protectedKeys.has(slot.key) }));
+};
+
+const hasUnannotatedPointerParam = (context: ModuleContext, slot: VtableSlot): boolean => {
+    const [, ...parameters] = slot.callback.parameters;
+
+    return parameters.some(
+        (parameter) =>
+            parameter.direction === "in" &&
+            parameter.cType?.endsWith("*") === true &&
+            isScalarRef(context.library, parameter.type),
+    );
+};
+
+const isCallableSlot = (context: ModuleContext, slot: VtableSlot): boolean =>
+    !UNCALLABLE_SLOT_KEYS.has(slot.key) && !hasUnannotatedPointerParam(context, slot);
+
+const vfuncSlotSignature = (context: ModuleContext, slot: VtableSlot, isOptional = false): VfuncSignature => {
+    const [, ...parameters] = slot.callback.parameters;
+
+    const renderType = (ref: TypeId | undefined, isNullable: boolean): string =>
+        renderTsType(context, ref, isNullable);
+
+    const signature = renderHandlerParameters(parameters, renderType).join(", ");
+    const folded = foldedLengthParameters(context.library, slot.callback);
+
+    const returnType = renderHandlerResultType({
+        library: context.library,
+        signal: { ...slot.callback, parameters },
+        renderType,
+        shouldIncludeCallerAllocated: true,
+        isOptOut: false,
+        shouldExcludeOut: (parameter) => folded.has(parameter),
+    });
+
+    return { header: `${slot.key}${isOptional ? "?" : ""}(${signature}): ${returnType}`, returnType };
+};
+
+const renderVfuncMember = (options: VfuncMemberOptions): string => {
+    const { context, ownerRef, slot, mode, isProtected } = options;
+    const { header, returnType } = vfuncSlotSignature(context, slot, mode === "requirement");
+    const declaration = `${isProtected ? "protected " : ""}${header}`;
+    const doc = renderJsDoc(slotDoc(slot), vfuncMemberNote(options), slotDocSpec(slot));
+
+    if (mode !== "implementation") {
+        return `${doc}${declaration};`;
+    }
+
+    const [, ...parameters] = slot.callback.parameters;
+
+    const inputs = handlerParameters(parameters).map((parameter, index) =>
+        parameterIdentifier(parameter, index));
+
+    const call = `callVfunc(${ownerRef}, ${sourceStringLiteral(slot.key)}, this, [${inputs.join(", ")}])`;
+    const body = returnType === "void" ? `${call};` : `return ${call} as ${returnType};`;
+
+    return `${doc}${renderBlock(declaration, body)}`;
+};
+
+const isEligibleVtableParam = (context: ModuleContext, param: GirParameter): boolean => {
+    if (param.isVarargs) {
         return false;
     }
 
@@ -146,8 +509,8 @@ const isVtableSlotEligible = (context: ModuleContext, callback: GirCallback): bo
     return !isInlineCallbackRef(context.library, callback.returnValue.type);
 };
 
-const renderVtableSlotDescriptor = (context: ModuleContext, options: RenderVtableSlotDescriptorOptions): string => {
-    const { key, structName, kind, field, callback, byteOffset, vtableSize } = options;
+const renderVtableSlotDescriptor = (context: ModuleContext, vtable: Vtable, slot: VtableSlot): string => {
+    const { key, field, callback, byteOffset } = slot;
 
     const argDescriptors = callback.parameters
         .map((param) => renderParamDescriptor(context, param, param.type))
@@ -160,16 +523,31 @@ const renderVtableSlotDescriptor = (context: ModuleContext, options: RenderVtabl
     );
 
     const lines = [
-        `kind: ${sourceStringLiteral(kind)} as const,`,
-        `className: ${sourceStringLiteral(structName)},`,
+        `className: ${sourceStringLiteral(vtable.structName)},`,
         `vfuncName: ${sourceStringLiteral(field.name)},`,
         `byteOffset: ${String(byteOffset)},`,
-        `vtableSize: ${String(vtableSize)},`,
-        `argDescriptors: [${argDescriptors}],`,
-        `returnDescriptor: ${returnDescriptor},`,
     ];
 
+    if (vtable.kind === "interface") {
+        lines.push(`vtableSize: ${String(vtable.vtableSize)},`);
+    }
+
+    lines.push(`argDescriptors: [${argDescriptors}],`, `returnDescriptor: ${returnDescriptor},`);
+
+    if (callback.throws) {
+        lines.push("canThrow: true,");
+    }
+
     return `${key}: ${renderBraced(lines.join("\n"))},`;
 };
 
-export { renderVfuncMetadata };
+export {
+    hasCallableVfuncSlots,
+    protectedChainSlotKeys,
+    renderVfuncMembers,
+    vfuncCallables,
+    renderVfuncMetadata,
+    vfuncEntries,
+    vfuncMemberNames,
+    type VfuncMemberMode,
+};

package/src/store/gi-store.ts

@@ -1,64 +1,59 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import type { SourceModule } from "../compile.js";
 import { FINGERPRINT_FILENAME, type GiFingerprint } from "../fingerprint.js";
-import { buildManifest, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
+import { buildManifest, namespaceBarrel, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
 
 type GiNamespaceInput = {
     directory: string;
     rawSource: string;
-};
-
-type CollectedFile = {
-    fileName: string;
-    source: string;
+    girFile: string;
 };
 
 const OVERRIDES_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "overrides");
 
-const overrideFiles = (directory: string): string[] => {
+const overrideFiles = (directory: string): SourceModule[] => {
     const dir = join(OVERRIDES_ROOT, directory);
 
     if (!existsSync(dir)) {
         return [];
     }
 
-    return readdirSync(dir).filter((name) => name.endsWith(".ejs") && name !== "index.ts.ejs");
+    return readdirSync(dir)
+        .filter((name) => name.endsWith(".ejs") && name !== "index.ts.ejs")
+        .map((name) => overrideModule(`${directory}/overrides/${name.replace(/\.ejs$/, "")}`, join(dir, name)));
 };
 
-const barrelSource = (directory: string): string => {
+const overrideModule = (fileName: string, overridePath: string): SourceModule => ({
+    fileName,
+    source: readFileSync(overridePath, "utf8"),
+    origin: overridePath,
+});
+
+const barrelFile = (directory: string, girFile: string): SourceModule => {
+    const barrel = namespaceBarrel(directory);
     const overrideIndex = join(OVERRIDES_ROOT, directory, "index.ts.ejs");
 
     if (!existsSync(overrideIndex)) {
-        return `export * from "./${directory}.js";\n`;
+        return { ...barrel, origin: girFile };
     }
 
-    return readFileSync(overrideIndex, "utf8");
+    return overrideModule(barrel.fileName, overrideIndex);
 };
 
 const collectStoreSources = (
     namespaces: GiNamespaceInput[],
-): { collected: CollectedFile[]; exportsMap: Record<string, unknown> } => {
+): { collected: SourceModule[]; exportsMap: Record<string, unknown> } => {
     const exportsMap: Record<string, unknown> = {};
-    const collected: CollectedFile[] = [];
-
-    for (const { directory, rawSource } of namespaces) {
-        collected.push({
-            fileName: `${directory}/${directory}.ts`,
-            source: rawSource,
-        });
-
-        for (const file of overrideFiles(directory)) {
-            collected.push({
-                fileName: `${directory}/overrides/${file.replace(/\.ejs$/, "")}`,
-                source: readFileSync(join(OVERRIDES_ROOT, directory, file), "utf8"),
-            });
-        }
-
-        collected.push({
-            fileName: `${directory}/index.ts`,
-            source: barrelSource(directory),
-        });
+    const collected: SourceModule[] = [];
+
+    for (const { directory, rawSource, girFile } of namespaces) {
+        collected.push(
+            { fileName: `${directory}/${directory}.ts`, source: rawSource, origin: girFile },
+            ...overrideFiles(directory),
+            barrelFile(directory, girFile),
+        );
 
         exportsMap[`./${directory}`] = subpathExport(`${directory}/index`);
     }