@gtkx/codegen 1.0.0-rc.3 → 1.0.0

package/src/store/gi/doc-spec.ts

@@ -0,0 +1,38 @@
+import type { GirAnnotations } from "../../gir/annotations.js";
+import type { GirCallable, GirParameter } from "../../gir/parameter.js";
+import type { JsDocSpec } from "../../writer/doc.js";
+import { documentedHandlerParameters, handlerRenames } from "../../analysis/param-structure.js";
+import { renderJsDoc } from "../../writer/doc.js";
+
+type DocumentedNode = { doc: string | undefined; annotations: GirAnnotations };
+
+const SELF_PARAM_DOC = "The instance the signal was emitted on.";
+const THROWS_TEXT = "A `GLib.Error` carrying the failing operation's domain, code, and message.";
+
+const annotationSpec = (annotations: GirAnnotations): JsDocSpec => ({
+    deprecated: annotations.isDeprecated
+        ? { since: annotations.deprecatedSince, doc: annotations.deprecationDoc }
+        : undefined,
+    since: annotations.since,
+});
+
+const getDoc = (node: DocumentedNode): string => renderJsDoc(node.doc, undefined, annotationSpec(node.annotations));
+
+const handlerSpec = (
+    callable: GirCallable,
+    parameters: GirParameter[],
+    identifiers?: Map<string, string>,
+): JsDocSpec => ({
+    ...annotationSpec(callable.annotations),
+    identifiers: identifiers ?? handlerRenames(parameters),
+    params: documentedHandlerParameters(parameters),
+    returns: callable.returnValue.doc,
+});
+
+const selfHandlerSpec = (signal: GirCallable): JsDocSpec => {
+    const spec = handlerSpec(signal, signal.parameters);
+
+    return { ...spec, params: [...(spec.params ?? []), { name: "self", doc: SELF_PARAM_DOC }] };
+};
+
+export { annotationSpec, getDoc, handlerSpec, selfHandlerSpec, THROWS_TEXT };

package/src/store/gi/enum.ts

@@ -1,47 +1,82 @@
 import { sourceStringLiteral } from "@gtkx/utils";
-import type { GirEnum } from "../../gir/enum.js";
+import type { EnumMember, GirEnum } from "../../gir/enum.js";
 import type { ModuleContext } from "../../writer/context.js";
-import { renderJsDoc } from "../../writer/doc.js";
+import { hasAnnotations } from "../../gir/annotations.js";
 import { indent } from "../../writer/emit.js";
+import { getDoc } from "./doc-spec.js";
+
+type KeyedMember = EnumMember & { key: string };
+
+const memberDoc = (member: KeyedMember): string =>
+    getDoc(member);
+
+const enumDoc = (enumeration: GirEnum): string =>
+    getDoc(enumeration);
 
 const generateEnum = (context: ModuleContext, enumeration: GirEnum): void => {
     if (!enumeration.introspectable) {
         return;
     }
 
-    const name = enumeration.name;
     const members = enumeration.members.map((member) => ({ ...member, key: enumMemberKey(member.name) }));
+    const errorDomain = enumeration.errorDomain;
 
-    if (enumeration.errorDomain !== undefined) {
-        const memberEntries = members.map((member) => `${member.key}: ${member.value}`);
-        const typeFields = members.map((member) => `${member.key}: number`).join("; ");
-        context.addRuntimeImport("createErrorDomain");
-        context.addRuntimeImport("ErrorDomain");
-        const quarkExpression = renderQuarkExpression(context, enumeration.errorDomain);
-        context.module.appendDeclaration(`${renderJsDoc(enumeration.doc)}export type ${name} = number;`);
-
-        context.module.appendDeclaration(
-            `export const ${name}: ErrorDomain<{ ${typeFields} }> = ` +
-            `createErrorDomain(${quarkExpression}, { ${memberEntries.join(", ")} });`,
-        );
+    if (errorDomain !== undefined) {
+        appendErrorDomain(context, enumeration, members, errorDomain);
 
         return;
     }
 
-    if (members.some((member) => member.doc !== undefined)) {
-        const memberBlocks = members.map((member) => `${renderJsDoc(member.doc)}${member.key} = ${member.value},`);
+    appendEnumDeclaration(context, enumeration, members);
+};
+
+const appendErrorDomain = (
+    context: ModuleContext,
+    enumeration: GirEnum,
+    members: KeyedMember[],
+    errorDomain: string,
+): void => {
+    const memberEntries = members.map((member) => `${member.key}: ${member.value}`);
+    const typeFields = members.map((member) => `${memberDoc(member)}${member.key}: number;`);
+    context.addRuntimeImport("createErrorDomain");
+    context.addRuntimeImport("ErrorDomain");
+    const quarkExpression = renderQuarkExpression(context, errorDomain);
+    const doc = enumDoc(enumeration);
+    const shape = typeFields.length === 0 ? "{}" : `{\n${indent(typeFields.join("\n"), 1)}\n}`;
+
+    context.module.appendDeclaration(
+        `${doc}export type ${enumeration.name} = number;`,
+        context.declaredType(enumeration.name),
+    );
+
+    context.module.appendDeclaration(
+        `${doc}export const ${enumeration.name}: ErrorDomain<${shape}> = ` +
+        `createErrorDomain(${quarkExpression}, { ${memberEntries.join(", ")} });`,
+    );
+};
+
+const isMemberDocumented = (member: KeyedMember): boolean =>
+    member.doc !== undefined || hasAnnotations(member.annotations);
+
+const appendEnumDeclaration = (context: ModuleContext, enumeration: GirEnum, members: KeyedMember[]): void => {
+    const doc = enumDoc(enumeration);
+
+    if (members.some((member) => isMemberDocumented(member))) {
+        const blocks = members.map((member) => `${memberDoc(member)}${member.key} = ${member.value},`);
 
         context.module.appendDeclaration(
-            `${renderJsDoc(enumeration.doc)}export enum ${name} {\n${indent(memberBlocks.join("\n"), 1)}\n}`,
+            `${doc}export enum ${enumeration.name} {\n${indent(blocks.join("\n"), 1)}\n}`,
+            context.declaredType(enumeration.name),
         );
 
         return;
     }
 
-    const memberDeclarations = members.map((member) => `${member.key} = ${member.value}`);
+    const declarations = members.map((member) => `${member.key} = ${member.value}`);
 
     context.module.appendDeclaration(
-        `${renderJsDoc(enumeration.doc)}export enum ${name} { ${memberDeclarations.join(", ")} }`,
+        `${doc}export enum ${enumeration.name} { ${declarations.join(", ")} }`,
+        context.declaredType(enumeration.name),
     );
 };
 

package/src/store/gi/function.ts

@@ -3,10 +3,10 @@ import type { GirFunction } from "../../gir/function.js";
 import type { GirNamespace } from "../../gir/namespace.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { tFn } from "../../analysis/descriptor.js";
-import { hasCallerAllocatedArrayLength } from "../../analysis/param-structure.js";
-import { renderJsDoc } from "../../writer/doc.js";
+import { hasUnmarshalableParam } from "../../analysis/param-capability.js";
 import { arrayLiteral, renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
+import { callableDoc } from "./callable-doc.js";
 import {
     planCallArgs,
     renderMethodBody,
@@ -17,6 +17,19 @@ import {
     renderReturnDescriptor,
 } from "./method.js";
 
+type NamespaceFinish = {
+    fn: GirFunction;
+    exportName: string;
+};
+
+type NamespaceFunctionOptions = {
+    context: ModuleContext;
+    fn: GirFunction;
+    finish: NamespaceFinish | undefined;
+    exportName: string;
+    bindingName: string;
+};
+
 const renderFnExpression = (context: ModuleContext, fn: GirFunction): string | undefined => {
     if (fn.cIdentifier === undefined) {
         return undefined;
@@ -32,13 +45,9 @@ const renderFnExpression = (context: ModuleContext, fn: GirFunction): string | u
     const params = planCallArgs(context, fn).map((arg) => arg.paramLiteral);
     const ret = renderReturnDescriptor(context, fn);
 
-    return tFn(library, fn.cIdentifier, { args: arrayLiteral(params), returns: ret, throws: fn.throws });
+    return tFn(library, fn.cIdentifier, { args: arrayLiteral(params), returns: ret, canThrow: fn.throws });
 };
 
-// `moved-to` names the type member this function is also reachable as, so the namespace-level copy
-// is a second export of one binding. Suppressing it is only right when that member is really
-// emitted: 15 of Gtk-4.0's 28 `moved-to` targets are enum or error-domain members codegen emits no
-// static for, and dropping those would delete API with nothing to replace it.
 const isMovedOntoEmittedMember = (context: ModuleContext, fn: GirFunction): boolean => {
     const [typeName, memberName] = fn.movedTo?.split(".") ?? [];
 
@@ -62,7 +71,7 @@ const canEmitNamespaceFunction = (context: ModuleContext, fn: GirFunction): bool
     !isMovedOntoEmittedMember(context, fn) &&
     fn.shadowedBy === undefined &&
     fn.cIdentifier !== undefined &&
-    !hasCallerAllocatedArrayLength(context.library, fn);
+    !hasUnmarshalableParam(context, fn);
 
 const generateNamespaceFunction = (context: ModuleContext, fn: GirFunction): void => {
     if (!canEmitNamespaceFunction(context, fn)) {
@@ -84,30 +93,39 @@ const generateNamespaceFunction = (context: ModuleContext, fn: GirFunction): voi
     const bindingName = toCamelIdentifier(cIdentifier);
     context.module.appendBinding(`const ${bindingName} = ${expression};`, cIdentifier);
     const exportName = namespaceFunctionExportName(cIdentifier, fn.name, context.namespace.cSymbolPrefixes);
-    const declaration = renderNamespaceFunctionDeclaration(context, fn, exportName, bindingName);
-    context.module.appendDeclaration(`${renderJsDoc(fn.doc)}${declaration}`);
+    const finish = matchNamespaceFinish(context, fn);
+    const declaration = renderNamespaceFunctionDeclaration({ context, fn, finish, exportName, bindingName });
+    const doc = callableDoc(context, fn, { finishFn: finish?.fn });
+    context.module.appendDeclaration(`${doc}${declaration}`);
 };
 
-const renderNamespaceFunctionDeclaration = (
-    context: ModuleContext,
-    fn: GirFunction,
-    exportName: string,
-    bindingName: string,
-): string => {
+const matchNamespaceFinish = (context: ModuleContext, fn: GirFunction): NamespaceFinish | undefined => {
     const finishFn = matchAsyncFinish(context.library, fn, context.namespace.functions);
-    const finishCIdentifier = finishFn?.cIdentifier;
+    const cIdentifier = finishFn?.cIdentifier;
+
+    if (finishFn === undefined || cIdentifier === undefined || !canEmitNamespaceFunction(context, finishFn)) {
+        return undefined;
+    }
+
+    return {
+        fn: finishFn,
+        exportName: namespaceFunctionExportName(cIdentifier, finishFn.name, context.namespace.cSymbolPrefixes),
+    };
+};
 
-    if (finishFn !== undefined && finishCIdentifier !== undefined && canEmitNamespaceFunction(context, finishFn)) {
-        const finishExport = namespaceFunctionExportName(
-            finishCIdentifier,
-            finishFn.name,
-            context.namespace.cSymbolPrefixes,
-        );
+const renderPromisifiedNamespaceFunction = (options: NamespaceFunctionOptions, finish: NamespaceFinish): string => {
+    const { context, fn, exportName, bindingName } = options;
+    const { signature, returnType } = renderPromisifiedSignature(context, fn, finish.fn);
+    const body = renderPromisifiedBody(context, fn, finish.exportName, bindingName);
+
+    return renderBlock(`export function ${exportName}(${signature}): ${returnType}`, body);
+};
 
-        const { signature, returnType } = renderPromisifiedSignature(context, fn, finishFn);
-        const body = renderPromisifiedBody(context, fn, finishExport, bindingName);
+const renderNamespaceFunctionDeclaration = (options: NamespaceFunctionOptions): string => {
+    const { context, fn, finish, exportName, bindingName } = options;
 
-        return renderBlock(`export function ${exportName}(${signature}): ${returnType}`, body);
+    if (finish !== undefined) {
+        return renderPromisifiedNamespaceFunction(options, finish);
     }
 
     const signature = renderMethodSignature(context, fn);

package/src/store/gi/interface.ts

@@ -1,20 +1,24 @@
-import { pascalCase } from "@gtkx/utils";
+import { pascalCase, sourceStringLiteral } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
-import type { GirFunction } from "../../gir/function.js";
+import type { GirProperty } from "../../gir/property.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { reservedSignalMemberRename, resolvePrerequisiteReference } from "../../analysis/inheritance.js";
+import { resolveInterfaces } from "../../gir/ancestry.js";
 import { renderJsDoc } from "../../writer/doc.js";
-import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
+import { renderBlock, renderBraced, renderBracedOrEmpty } from "../../writer/emit.js";
 import {
     type Callables,
     dedupeCallables,
     generateBindings,
+    type InstanceMemberRenderer,
     type InstanceScope,
     instanceScope,
+    isEmittableCallable,
     renderClassInstanceMember,
     renderInstanceMethodSignature,
     renderStaticHead,
 } from "./callables.js";
+import { annotationSpec, getDoc } from "./doc-spec.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import {
@@ -24,15 +28,15 @@ import {
 } from "./property-accessor.js";
 import { appendInterfaceRegistration } from "./registration.js";
 import { renderSignalDeclarations, renderSignalMembers } from "./signal.js";
-import { renderVfuncMetadata } from "./vtable.js";
+import {
+    hasCallableVfuncSlots,
+    renderVfuncMembers,
+    renderVfuncMetadata,
+    type VfuncMemberMode,
+} from "./vtable.js";
 
 type InterfaceMemberRenderers = {
-    renderMethod: (
-        context: ModuleContext,
-        callable: GirFunction,
-        scope: InstanceScope,
-        nameOverride?: string,
-    ) => string | undefined;
+    renderMethod: InstanceMemberRenderer;
     renderProperty: (args: PropertyAccessorArgs) => string | undefined;
 };
 
@@ -53,6 +57,20 @@ type PropertyMemberOptions = {
     claimedNames: Set<string>;
 };
 
+type InterfaceClassOptions = {
+    iface: GirClass;
+    className: string;
+    callables: Callables;
+    gtypeExpr: string | undefined;
+    implRef: string;
+};
+
+const BRAND_NOTE = [
+    "Phantom link to the type a class fills to adopt the interface, which `registerClass` reads",
+    "through its `implements` option. It holds no value at runtime. `unknown` asks nothing of the",
+    "class, which is what an interface with no slot to fill carries.",
+].join("\n");
+
 const generateInterface = (context: ModuleContext, iface: GirClass): void => {
     if (!iface.introspectable) {
         return;
@@ -72,8 +90,9 @@ const generateInterface = (context: ModuleContext, iface: GirClass): void => {
 
     generateBindings(context, callables);
     const gtypeExpr = renderSourceGtype(context, iface);
-    context.module.appendDeclaration(renderInterfaceType(context, iface, className, callables));
-    context.module.appendDeclaration(renderInterfaceClass(context, className, callables, gtypeExpr));
+    const implRef = appendInterfaceTypes(context, iface, className, callables) ?? "unknown";
+    const classCode = renderInterfaceClass(context, { iface, className, callables, gtypeExpr, implRef });
+    context.module.appendDeclaration(classCode, context.declaredType(className));
 
     for (const declaration of renderSignalDeclarations(context, iface, className, true)) {
         context.module.appendDeclaration(declaration);
@@ -85,12 +104,116 @@ const generateInterface = (context: ModuleContext, iface: GirClass): void => {
         className,
         makerName: makerName(className),
         gtypeExpr,
-        vfuncs: renderVfuncMetadata(context, iface),
+        layout: renderInterfaceLayout(context, iface, callables),
     });
 };
 
 const makerName = (className: string): string => `make${className}`;
 
+const renderInterfaceLayout = (
+    context: ModuleContext,
+    iface: GirClass,
+    callables: Callables,
+): string | undefined => {
+    const vfuncs = renderVfuncMetadata(context, iface);
+    const properties = renderSlotBackedProperties(context, iface, callables);
+
+    if (vfuncs === undefined && properties === undefined) {
+        return undefined;
+    }
+
+    const entries: string[] = [];
+
+    if (vfuncs !== undefined) {
+        entries.push(`vfuncs: ${vfuncs},`);
+    }
+
+    if (properties !== undefined) {
+        entries.push(`properties: ${properties},`);
+    }
+
+    return renderBraced(entries.join("\n"));
+};
+
+const invokerMembers = (context: ModuleContext, iface: GirClass, callables: Callables): Map<string, string> => {
+    const className = pascalCase(iface.name);
+
+    const invokers: Set<string> = new Set(
+        iface.vfuncs.map((vfunc) => vfunc.invoker).filter((invoker) => invoker !== undefined),
+    );
+
+    const members: Map<string, string> = new Map();
+
+    for (const callable of callables.methods) {
+        if (invokers.has(callable.name) && isEmittableCallable(context, callable)) {
+            members.set(callable.name, reservedSignalMemberRename(className, callable) ?? methodExportName(callable));
+        }
+    }
+
+    return members;
+};
+
+const renderSlotAccessor = (
+    key: string,
+    method: string | undefined,
+    members: Map<string, string>,
+): string | undefined => {
+    const member = method === undefined ? undefined : members.get(method);
+
+    return member === undefined ? undefined : `${key}: ${sourceStringLiteral(member)},`;
+};
+
+const renderSlotBackedProperty = (property: GirProperty, members: Map<string, string>): string | undefined => {
+    if (!property.introspectable) {
+        return undefined;
+    }
+
+    const fields = [
+        renderSlotAccessor("getter", property.getter, members),
+        renderSlotAccessor("setter", property.setter, members),
+    ].filter((field) => field !== undefined);
+
+    if (fields.length === 0) {
+        return undefined;
+    }
+
+    return `${sourceStringLiteral(property.name)}: ${renderBraced(fields.join("\n"))},`;
+};
+
+const renderSlotBackedProperties = (
+    context: ModuleContext,
+    iface: GirClass,
+    callables: Callables,
+): string | undefined => {
+    const members = invokerMembers(context, iface, callables);
+
+    const entries = iface.properties
+        .map((property) => renderSlotBackedProperty(property, members))
+        .filter((entry) => entry !== undefined);
+
+    return entries.length === 0 ? undefined : renderBraced(entries.join("\n"));
+};
+
+const appendInterfaceTypes = (
+    context: ModuleContext,
+    iface: GirClass,
+    className: string,
+    callables: Callables,
+): string | undefined => {
+    const typeCode = renderInterfaceType(context, iface, className, callables);
+    context.module.appendDeclaration(typeCode, context.declaredType(className));
+    const implType = renderInterfaceImplType(context, iface, className);
+
+    if (implType === undefined) {
+        return undefined;
+    }
+
+    const implName = implTypeName(className);
+    context.module.appendDeclaration(implType, context.declaredType(className, implName));
+
+    return implName;
+};
+
 const interfaceTypeExtends = (context: ModuleContext, iface: GirClass): string => {
     const refs = iface.prerequisites
         .map((name) => resolvePrerequisiteReference(context, name))
@@ -111,12 +234,69 @@ const renderInterfaceType = (
 ): string => {
     const members = renderInterfaceTypeMembers(context, iface, callables);
 
-    return `${renderJsDoc(iface.doc)}${renderBracedOrEmpty(
+    return `${getDoc(iface)}${renderBracedOrEmpty(
         `export interface ${className} extends ${interfaceTypeExtends(context, iface)}`,
         members.join("\n"),
     )}`;
 };
 
+const implTypeName = (className: string): string => `${className}Impl`;
+
+const implTypeNote = (className: string): string =>
+    [
+        `Implementer side of \`${className}\`: the vtable slots a class fills to adopt the interface.`,
+        "",
+        `Declare it with \`implements ${implTypeName(className)}\` on a class passed to \`registerClass\``,
+        `with \`${className}\` in \`implements\`. The interface's methods, properties, and signals come from`,
+        "GLib dispatch, so they are not part of this type.",
+        "",
+        "Every slot is optional: an unfilled one keeps whatever the interface installs by default, and a",
+        "GIR update can add one. Declaring a slot pins its signature; declaring it as a class field rather",
+        "than a method satisfies this type but never reaches the vtable.",
+    ].join("\n");
+
+const implPrerequisiteRefs = (context: ModuleContext, iface: GirClass): string[] => {
+    const prerequisites = resolveInterfaces(context.library, context.namespace.name, iface.prerequisites);
+    const refs: string[] = [];
+
+    for (const prerequisite of prerequisites) {
+        if (!hasCallableVfuncSlots(context, prerequisite.namespaceName, prerequisite.klass)) {
+            continue;
+        }
+
+        const name = implTypeName(pascalCase(prerequisite.klass.name));
+        refs.push(context.qualify(prerequisite.namespaceName, name));
+    }
+
+    return refs;
+};
+
+const implTypeExtends = (context: ModuleContext, iface: GirClass): string => {
+    const refs = implPrerequisiteRefs(context, iface);
+
+    return refs.length > 0 ? ` extends ${refs.join(", ")}` : "";
+};
+
+const interfaceVfuncMembers = (context: ModuleContext, iface: GirClass, mode: VfuncMemberMode): string[] =>
+    renderVfuncMembers({ context, klass: iface, mode });
+
+const renderInterfaceImplType = (
+    context: ModuleContext,
+    iface: GirClass,
+    className: string,
+): string | undefined => {
+    const members = interfaceVfuncMembers(context, iface, "requirement");
+
+    if (members.length === 0) {
+        return undefined;
+    }
+
+    return `${renderJsDoc(iface.doc, implTypeNote(className), annotationSpec(iface.annotations))}${renderBracedOrEmpty(
+        `export interface ${implTypeName(className)}${implTypeExtends(context, iface)}`,
+        members.join("\n"),
+    )}`;
+};
+
 const collectMethodMembers = (options: MethodMemberOptions): string[] => {
     const { context, className, scope, callables, renderers, claimedNames } = options;
     const members: string[] = [];
@@ -166,27 +346,34 @@ const renderInterfaceMembers = (
     return [...methodMembers, ...propertyMembers];
 };
 
-const renderInterfaceTypeMembers = (context: ModuleContext, iface: GirClass, callables: Callables): string[] =>
-    renderInterfaceMembers(context, iface, callables, {
+const renderInterfaceTypeMembers = (context: ModuleContext, iface: GirClass, callables: Callables): string[] => [
+    ...renderInterfaceMembers(context, iface, callables, {
         renderMethod: renderInstanceMethodSignature,
         renderProperty: renderPropertyAccessorSignature,
-    });
+    }),
+    ...interfaceVfuncMembers(context, iface, "signature"),
+];
 
-const renderInterfaceClass = (
-    context: ModuleContext,
-    className: string,
-    callables: Callables,
-    gtypeExpr: string | undefined,
-): string => {
+const renderInterfaceClass = (context: ModuleContext, options: InterfaceClassOptions): string => {
+    const { iface, className, callables, gtypeExpr, implRef } = options;
     const members: string[] = [];
 
     if (gtypeExpr !== undefined) {
         members.push(renderInterfaceHasInstance(context, className, gtypeExpr));
     }
 
-    members.push(...renderStaticHead(context, callables, className));
+    members.push(...renderStaticHead(context, callables, className), renderInterfaceBrand(context, implRef));
+
+    return `${getDoc(iface)}${renderBracedOrEmpty(
+        `export abstract class ${className}`,
+        members.join("\n\n"),
+    )}`;
+};
+
+const renderInterfaceBrand = (context: ModuleContext, implRef: string): string => {
+    context.addRuntimeTypeImport("Interface");
 
-    return renderBracedOrEmpty(`export abstract class ${className}`, members.join("\n\n"));
+    return `${renderJsDoc(undefined, BRAND_NOTE)}declare static __impl__: Interface<${implRef}>["__impl__"];`;
 };
 
 const renderInterfaceHasInstance = (context: ModuleContext, className: string, gtypeExpr: string): string => {
@@ -208,7 +395,7 @@ const renderInterfaceMaker = (
     const members = renderInterfaceInstanceMembers(context, iface, callables);
     const classExpression = renderBracedOrEmpty("class extends Base", members.join("\n\n"));
 
-    return `export const ${makerName(className)}: Mixin = (Base) =>\n${classExpression};`;
+    return `${getDoc(iface)}export const ${makerName(className)}: Mixin = (Base) =>\n${classExpression};`;
 };
 
 const renderInterfaceInstanceMembers = (context: ModuleContext, iface: GirClass, callables: Callables): string[] => [
@@ -216,6 +403,7 @@ const renderInterfaceInstanceMembers = (context: ModuleContext, iface: GirClass,
         renderMethod: renderClassInstanceMember,
         renderProperty: renderPropertyAccessor,
     }),
+    ...interfaceVfuncMembers(context, iface, "implementation"),
     ...renderSignalMembers(context, iface),
 ];
 

package/src/store/gi/item-comparators.ts

@@ -5,7 +5,7 @@ import type { ModuleContext } from "../../writer/context.js";
 import { tObject } from "../../analysis/descriptor.js";
 import { inputParameters, parameterIdentifier } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
-import { resolveInterface } from "../../gir/ancestry.js";
+import { resolveInterfaces } from "../../gir/ancestry.js";
 import { callbackAsFunction, type GirCallback } from "../../gir/callback.js";
 
 const COMPARATOR_CALLBACK_TYPES = new Set([
@@ -30,11 +30,9 @@ const isListModelImplementor = (context: ModuleContext, ref: TypeId): boolean =>
         return false;
     }
 
-    return resolved.value.implements.some((interfaceName) => {
-        const iface = resolveInterface(context.library, resolved.namespace.name, interfaceName);
+    const interfaces = resolveInterfaces(context.library, resolved.namespace.name, resolved.value.implements);
 
-        return iface?.namespaceName === "Gio" && iface.klass.name === "ListModel";
-    });
+    return interfaces.some((iface) => iface.namespaceName === "Gio" && iface.klass.name === "ListModel");
 };
 
 const isObjectItemComparator = (context: ModuleContext, fn: GirFunction): boolean => {