@gtkx/codegen 1.0.0 → 1.2.0

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

@@ -46,6 +46,16 @@ const computeRecordFieldSlots = (
     return { slots, size: result.size };
 };
 
+const recordInlineSize = (context: ModuleContext, record: ResolvedRecordValue): number | undefined => {
+    if (record.opaque || record.disguised || record.fields.length === 0) {
+        return undefined;
+    }
+
+    const { size } = computeRecordFieldSlots(context, record.fields, record.isUnion);
+
+    return size > 0 ? size : undefined;
+};
+
 const bitMask = (width: number): number => {
     if (width >= 32) {
         return 0xFF_FF_FF_FF;
@@ -214,4 +224,4 @@ const resolveAliasLayout = (
     return layoutOfType(context, ref, resolved.value.targetCType, visited);
 };
 
-export { computeRecordFieldSlots, bitMask, mergeBitfield, type RecordFieldSlot };
+export { computeRecordFieldSlots, recordInlineSize, bitMask, mergeBitfield, type RecordFieldSlot };

package/src/store/gi/record.ts

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

package/src/store/gi/registration.ts

@@ -25,7 +25,7 @@ const appendWrapperClassRegistration = (
 
     context.addRuntimeImport("registerWrapperClass");
     const args = vfuncs === undefined ? gtypeExpr : `${gtypeExpr}, ${vfuncs}`;
-    context.module.appendRegistration(`registerWrapperClass(${className}, ${args});`);
+    context.module.appendRegistration(`registerWrapperClass(${className}, ${args});`, [className]);
 };
 
 const appendInterfaceRegistration = (context: ModuleContext, registration: InterfaceRegistration): void => {
@@ -38,7 +38,7 @@ const appendInterfaceRegistration = (context: ModuleContext, registration: Inter
     context.addRuntimeImport("registerInterface");
     const base = `${className}, ${gtypeExpr}, ${makerName}`;
     const args = layout === undefined ? base : `${base}, ${layout}`;
-    context.module.appendRegistration(`registerInterface(${args});`);
+    context.module.appendRegistration(`registerInterface(${args});`, [className, makerName]);
 };
 
 export { appendWrapperClassRegistration, appendInterfaceRegistration };

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

@@ -10,7 +10,7 @@ type WrapReturnOptions = {
     valueExpression: string;
 };
 
-const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["gtype", "bigint64", "biguint64"]);
+const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["gtype", "bigint64", "biguint64", "pointer"]);
 
 const wrapReturnValue = (context: ModuleContext, options: WrapReturnOptions): string => {
     const { ref, isNullable, valueExpression } = options;

package/src/store/gi/signal.ts

@@ -1,13 +1,14 @@
 import { camelCase, sourceStringLiteral } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
-import type { GirCallable, GirParameter } from "../../gir/parameter.js";
+import type { GirCallable, GirParameter, GirReturnValue } from "../../gir/parameter.js";
 import type { GirProperty } from "../../gir/property.js";
 import type { ModuleContext } from "../../writer/context.js";
+import type { Declaration } from "../../writer/module.js";
 import {
     isCellInout,
+    primaryReturnKind,
     renderDescriptor,
     renderParamDescriptor,
-    shouldOmitPrimaryReturn,
 } from "../../analysis/descriptor-render.js";
 import { tCallback, tObject, tVoid } from "../../analysis/descriptor.js";
 import {
@@ -23,7 +24,7 @@ import { renderJsDoc } from "../../writer/doc.js";
 import { indent, renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
 import { parentCompanionRef } from "./companion.js";
 import { getDoc, handlerSpec } from "./doc-spec.js";
-import { isRecordCallerOut, isRecordInout } from "./param-marshal.js";
+import { isAllocatableCallerOut, isRecordInout, renderCallerOutInstance } from "./param-marshal.js";
 
 type SignalMapSpec = {
     context: ModuleContext;
@@ -47,6 +48,21 @@ const SIGNAL_HANDLER_TYPE = "(...args: any[]) => any";
 const SIGNALS_SUFFIX = "Signals";
 const SIGNAL_EMIT_SUFFIX = "SignalEmit";
 
+const DEPRECATED_SIGNAL_ALIASES: Map<string, string> = new Map([
+    ["addEventListener", "on"],
+    ["removeEventListener", "off"],
+]);
+
+const deprecatedAliasDoc = (method: string): string => {
+    const replacement = DEPRECATED_SIGNAL_ALIASES.get(method);
+
+    if (replacement === undefined) {
+        return "";
+    }
+
+    return `/** @deprecated Since 1.2. Use \`${replacement}\` instead. Removed in v2. */\n`;
+};
+
 const renderSignalMembers = (context: ModuleContext, klass: GirClass): string[] => {
     if (klass.glibGetType === undefined) {
         return [];
@@ -67,7 +83,7 @@ const renderSignalMembers = (context: ModuleContext, klass: GirClass): string[]
 
     const connectDefault = isRootObject
         ? "default:\n    throw new globalThis.Error(\"Unknown signal '\" + signal + \"'\");"
-        : "default:\n    return super.connect(signal, handler, isAfter);";
+        : "default:\n    return super.connect(signal as never, handler as never, isAfter);";
 
     const emitDefault = isRootObject
         ? "default:\n    throw new globalThis.Error(\"Unknown signal '\" + sigName + \"'\");"
@@ -92,12 +108,18 @@ const renderSignalDeclarations = (
     klass: GirClass,
     className: string,
     isParentlessObjectSubclass: boolean,
-): string[] => {
+): Declaration[] => {
     const base = { context, klass, className, isParentlessObjectSubclass };
 
-    const declarations = [
-        renderSignalMap({ ...base, suffix: SIGNALS_SUFFIX, renderEntry: renderSignalHandlerType }),
-        renderSignalMap({ ...base, suffix: SIGNAL_EMIT_SUFFIX, renderEntry: renderSignalEmitEntry }),
+    const declarations: Declaration[] = [
+        {
+            name: `${className}${SIGNALS_SUFFIX}`,
+            code: renderSignalMap({ ...base, suffix: SIGNALS_SUFFIX, renderEntry: renderSignalHandlerType }),
+        },
+        {
+            name: `${className}${SIGNAL_EMIT_SUFFIX}`,
+            code: renderSignalMap({ ...base, suffix: SIGNAL_EMIT_SUFFIX, renderEntry: renderSignalEmitEntry }),
+        },
     ];
 
     if (
@@ -107,7 +129,7 @@ const renderSignalDeclarations = (
             klass.implements.length > 0)
     ) {
         const isRootObject = context.namespace.name === "GObject" && klass.name === "Object";
-        declarations.push(renderSignalConnectInterface(className, isRootObject));
+        declarations.push({ name: className, code: renderSignalConnectInterface(className, isRootObject) });
     }
 
     return declarations;
@@ -122,7 +144,11 @@ const renderSignalMap = (spec: SignalMapSpec): string => {
         (signal) => `${signalDoc(signal)}${sourceStringLiteral(signal.name)}: ${renderEntry(context, signal)};`,
     );
 
-    const entries = [...signalEntries, ...renderNotifyDetailEntries(context, klass, suffix)];
+    const entries = [
+        ...signalEntries,
+        ...renderNotifyDetailEntries(context, klass, suffix),
+        ...renderCustomNotifyEntry(context, klass, suffix),
+    ];
 
     return renderBracedOrEmpty(`export interface ${className}${suffix}${extendsClause}`, entries.join("\n"));
 };
@@ -130,6 +156,14 @@ const renderSignalMap = (spec: SignalMapSpec): string => {
 const signalDoc = (signal: GirCallable): string =>
     renderJsDoc(signal.doc, undefined, handlerSpec(signal, signal.parameters));
 
+const renderCustomNotifyEntry = (context: ModuleContext, klass: GirClass, suffix: string): string[] => {
+    if (context.namespace.name !== "GObject" || klass.name !== "Object") {
+        return [];
+    }
+
+    return [`[detail: \`notify::\${string}\`]: ${gobjectObjectMapRef(context, suffix)}["notify"];`];
+};
+
 const renderNotifyDetailEntries = (context: ModuleContext, klass: GirClass, suffix: string): string[] => {
     const notifyValue = `${gobjectObjectMapRef(context, suffix)}["notify"]`;
 
@@ -184,7 +218,6 @@ const renderSignalConnectInterface = (className: string, isRootObject: boolean):
     const lines = [
         `__signals__?: ${map};`,
         `connect<K extends keyof ${map}>(signal: K, handler: ${map}[K], isAfter?: boolean): number;`,
-        `connect(signal: string, handler: ${SIGNAL_HANDLER_TYPE}, isAfter?: boolean): number;`,
         `emit<K extends keyof ${emitMap}>(sigName: K, ...args: ${emitMap}[K]["args"]): ${emitMap}[K]["result"];`,
         "emit(sigName: string, ...args: unknown[]): unknown;",
     ];
@@ -193,8 +226,8 @@ const renderSignalConnectInterface = (className: string, isRootObject: boolean):
         const chainable = (methods: string[], trailing: string): void => {
             for (const method of methods) {
                 lines.push(
+                    deprecatedAliasDoc(method) +
                     `${method}<K extends keyof ${map}>(signal: K, handler: ${map}[K]${trailing}): this;`,
-                    `${method}(signal: string, handler: ${SIGNAL_HANDLER_TYPE}${trailing}): this;`,
                 );
             }
         };
@@ -263,7 +296,7 @@ const renderEmitArgLiteral = (options: EmitArgOptions): { literal: string; nextA
     }
 
     if (isCallerAllocatedOut(parameter)) {
-        const value = renderCallerOutAllocation(context, parameter);
+        const value = renderCallerOutInstance(context, parameter);
 
         return {
             literal: `{ type: ${descriptor}, direction: "out", isCallerAllocated: true, value: ${value} }`,
@@ -283,10 +316,18 @@ const renderEmitArgLiteral = (options: EmitArgOptions): { literal: string; nextA
     return { literal: `{ type: ${descriptor}, value: args[${String(argIndex)}] }`, nextArgIndex: argIndex + 1 };
 };
 
+const renderEmitReturnArg = (context: ModuleContext, returnValue: GirReturnValue): string => {
+    if (primaryReturnKind(context.library, returnValue) === "void") {
+        return "";
+    }
+
+    return `, ${renderDescriptor(context, returnValue.type, returnValue.transferOwnership)}`;
+};
+
 const renderEmitCase = (context: ModuleContext, signal: GirCallable): string => {
     const params = nonVarargParameters(signal);
 
-    if (params.some((parameter) => isCallerAllocatedOut(parameter) && !isRecordCallerOut(context, parameter))) {
+    if (params.some((parameter) => isCallerAllocatedOut(parameter) && !isAllocatableCallerOut(context, parameter))) {
         return renderUnsupportedEmitCase(signal);
     }
 
@@ -301,12 +342,7 @@ const renderEmitCase = (context: ModuleContext, signal: GirCallable): string =>
         return rendered.literal;
     });
 
-    const isVoid = shouldOmitPrimaryReturn(context.library, signal.returnValue);
-
-    const returnArg = isVoid
-        ? ""
-        : `, ${renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership)}`;
-
+    const returnArg = renderEmitReturnArg(context, signal.returnValue);
     const body = `return emitSignal(this, sigName, [${argLiterals.join(", ")}]${returnArg});`;
 
     return renderBlock(`case ${sourceStringLiteral(signal.name)}:`, body);
@@ -321,16 +357,6 @@ const renderUnsupportedEmitCase = (signal: GirCallable): string => {
     );
 };
 
-const renderCallerOutAllocation = (context: ModuleContext, parameter: GirParameter): string => {
-    const name = parameter.type === undefined ? undefined : context.library.nameFor(parameter.type);
-
-    if (name === undefined) {
-        throw new Error("renderCallerOutAllocation: expected a named caller-allocated out-parameter");
-    }
-
-    return `new ${context.qualify(name.namespaceName, name.typeName)}()`;
-};
-
 const renderCallback = (context: ModuleContext, signal: GirCallable): string => {
     const params = nonVarargParameters(signal);
 
@@ -338,21 +364,19 @@ const renderCallback = (context: ModuleContext, signal: GirCallable): string =>
         renderParamDescriptor(context, parameter, parameter.type, { argIndexOffset: 1 }),
     );
 
-    const isVoid = shouldOmitPrimaryReturn(context.library, signal.returnValue);
-
-    const returnDescriptor = isVoid
-        ? tVoid
-        : renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership);
-
     const callbackArgs = [tObject("borrowed"), ...callbackParamDescriptors, tVoid];
     const userDataIndex = String(params.length + 1);
-    const destroy = "hasDestroy: true, destroyKind: \"closureNotify\"";
 
-    return tCallback(
-        callbackArgs,
-        returnDescriptor,
-        `{ ${destroy}, hasUserData: true, userDataIndex: ${userDataIndex} }`,
-    );
+    return tCallback({
+        argTypes: callbackArgs,
+        returns: renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership),
+        options: [
+            "hasDestroy: true",
+            "destroyKind: \"closureNotify\"",
+            "hasUserData: true",
+            `userDataIndex: ${userDataIndex}`,
+        ],
+    });
 };
 
 const forEachInterfaceSignal = (

package/src/store/gi/value-marshalable.ts

@@ -15,6 +15,8 @@ const hasOwnCopySemantics = (record: GirRecord): boolean =>
     record.glibGetType !== undefined ||
     ((record.glibRefFunc ?? record.copyFunc) !== undefined && (record.glibUnrefFunc ?? record.freeFunc) !== undefined);
 
+const isOpaqueRecord = (record: GirRecord): boolean => record.opaque || record.disguised;
+
 const isValueSafeArray = (scope: Scope, type: Extract<GirType, { kind: "carray" }>): boolean =>
     type.fixedSize !== undefined && isValueSafeRef(scope, type.element, type.elementCType);
 
@@ -82,6 +84,6 @@ const isValueMarshalable = (context: ModuleContext, namespaceName: string, recor
     isValueSafeRecord({ context, seen: new Set<string>() }, namespaceName, record);
 
 const isConstructibleRecord = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
-    hasOwnCopySemantics(record) || isValueMarshalable(context, namespaceName, record);
+    !isOpaqueRecord(record) && (hasOwnCopySemantics(record) || isValueMarshalable(context, namespaceName, record));
 
 export { isConstructibleRecord, isValueMarshalable };

package/src/store/gi/vtable.ts

@@ -1,7 +1,8 @@
-import { pascalCase, sourceStringLiteral } from "@gtkx/utils";
-import type { GirCallback } from "../../gir/callback.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";
@@ -22,7 +23,9 @@ import {
     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";
@@ -80,6 +83,7 @@ const UNCALLABLE_SLOT_KEYS: Set<string> = new Set([
     "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.";
 
@@ -193,7 +197,7 @@ const attachVirtualMethods = (slots: VtableSlot[], klass: GirClass): VtableSlot[
     return slots.map((slot) => ({ ...slot, vfunc: byKey.get(slot.key) }));
 };
 
-const collectVtable = (context: ModuleContext, namespaceName: string, klass: GirClass): Vtable | undefined => {
+const buildVtable = (context: ModuleContext, namespaceName: string, klass: GirClass): Vtable | undefined => {
     const resolved = resolveVtableRecord(context, namespaceName, klass);
 
     if (resolved === undefined) {
@@ -210,10 +214,63 @@ const collectVtable = (context: ModuleContext, namespaceName: string, klass: Gir
         structName: pascalCase(resolved.typeStruct),
         kind: klass.isInterface ? "interface" : "class",
         vtableSize,
-        slots: attachVirtualMethods(slots, klass),
+        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);
+    }
+
+    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) ?? [];
 
@@ -231,21 +288,8 @@ const renderVfuncMetadata = (context: ModuleContext, klass: GirClass): string |
 
 const slotIdentity = (slot: VtableSlot): string => `${slot.key}:${String(slot.byteOffset)}`;
 
-const inheritedSlotIdentities = (context: ModuleContext, namespaceName: string, klass: GirClass): Set<string> => {
-    const identities: Set<string> = new Set();
-    const [, ...ancestors] = [...ancestorChain(context.library, klass, namespaceName)];
-
-    for (const ancestor of ancestors) {
-        const vtable = collectVtable(context, ancestor.namespaceName, ancestor.klass);
-        const slots = vtable?.slots ?? [];
-
-        for (const slot of slots) {
-            identities.add(slotIdentity(slot));
-        }
-    }
-
-    return identities;
-};
+const inheritedSlotIdentities = (context: ModuleContext, namespaceName: string, klass: GirClass): Set<string> =>
+    new Set(ancestorSlots(context, namespaceName, klass).map((slot) => slotIdentity(slot)));
 
 const addInterfaceSlotKeys = (
     context: ModuleContext,
@@ -295,6 +339,37 @@ const protectedSlotKeys = (options: VfuncMembersOptions, slots: VtableSlot[]): S
     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);
 
@@ -339,7 +414,7 @@ const vfuncEntries = (context: ModuleContext, namespaceName: string, klass: GirC
 
 const renderVfuncMembers = (options: VfuncMembersOptions): string[] => {
     const { context, klass, mode } = options;
-    const ownerRef = pascalCase(klass.name);
+    const ownerRef = sanitizeTypeIdentifier(klass.name);
     const slots = callableVfuncSlots(context, context.namespace.name, klass);
 
     if (slots.length === 0) {
@@ -468,7 +543,9 @@ const renderVtableSlotDescriptor = (context: ModuleContext, vtable: Vtable, slot
 
 export {
     hasCallableVfuncSlots,
+    protectedChainSlotKeys,
     renderVfuncMembers,
+    vfuncCallables,
     renderVfuncMetadata,
     vfuncEntries,
     vfuncMemberNames,

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`);
     }