@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.2

package/src/store/gi/constructor-props.ts

@@ -1,27 +1,38 @@
 import { sourceStringLiteral, toCamelIdentifier, uniqBy } from "@gtkx/utils";
+import type { GirClass } from "../../gir/class.js";
+import type { ModuleContext } from "../../writer/context.js";
 import { renderDescriptor } from "../../analysis/descriptor-render.js";
 import { collectInterfaceProperties } from "../../analysis/inheritance.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { ancestorChain } from "../../gir/ancestry.js";
-import type { GirClass } from "../../gir/class.js";
 import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
-import type { ModuleContext } from "../../writer/context.js";
 import { renderBlock, renderBraced, renderBracedOrEmpty } from "../../writer/emit.js";
 import { parentCompanionRef } from "./companion.js";
 
+const PROPS_RECORD = "Record<string, unknown>";
+
+const constructablePropNames = (klass: GirClass): string[] =>
+    klass.properties.filter(isConstructableProperty).map((property) => toCamelIdentifier(property.name));
+
 const ancestorConstructablePropNames = (context: ModuleContext, klass: GirClass): Set<string> => {
-    const names = new Set<string>();
+    const names: Set<string> = new Set();
+
     for (const { klass: ancestor } of ancestorChain(context.library, klass, context.namespace.name)) {
-        if (ancestor === klass) continue;
-        for (const property of ancestor.properties) {
-            if (isConstructableProperty(property)) names.add(toCamelIdentifier(property.name));
+        if (ancestor === klass) {
+            continue;
+        }
+
+        for (const name of constructablePropNames(ancestor)) {
+            names.add(name);
         }
     }
+
     return names;
 };
 
 const collectConstructableProps = (context: ModuleContext, klass: GirClass): GirProperty[] => {
     const inherited = ancestorConstructablePropNames(context, klass);
+
     return uniqBy(
         [...klass.properties, ...collectInterfaceProperties(context, klass).map((entry) => entry.property)]
             .filter(isConstructableProperty)
@@ -30,40 +41,49 @@ const collectConstructableProps = (context: ModuleContext, klass: GirClass): Gir
     );
 };
 
-export const renderConstructorPropsInterface = (context: ModuleContext, klass: GirClass, className: string): string => {
+const renderConstructorPropsInterface = (context: ModuleContext, klass: GirClass, className: string): string => {
     const parentRef = parentCompanionRef(context, klass, "ConstructorProps");
     const extendsClause = parentRef === undefined ? "" : ` extends ${parentRef}`;
+
     const lines = collectConstructableProps(context, klass).map(
         (property) =>
             `${toCamelIdentifier(property.name)}?: ${renderTsType(context, property.type, true)} | undefined;`,
     );
+
     return renderBracedOrEmpty(`export interface ${className}ConstructorProps${extendsClause}`, lines.join("\n"));
 };
 
-export const renderClassConstructor = (
+const renderClassConstructor = (
     context: ModuleContext,
     klass: GirClass,
     className: string,
     hasParent: boolean,
 ): string | undefined => {
-    if (!hasParent) return renderRootConstructor(context);
+    if (!hasParent) {
+        return renderRootConstructor(context);
+    }
+
     const props = collectConstructableProps(context, klass);
-    if (props.length === 0) return undefined;
+
+    if (props.length === 0) {
+        return undefined;
+    }
+
     return renderTranslatingConstructor(context, props, className);
 };
 
-const PROPS_RECORD = "Record<string, unknown>";
-
 const renderRootConstructor = (context: ModuleContext): string => {
     context.addRuntimeImport("getInstanceType");
     context.addRuntimeImport("newObjectWithProperties");
     context.addRuntimeImport("setHandle");
     context.addRuntimeImport("setWrapper");
+
     const body = [
         "const handle = newObjectWithProperties(getInstanceType(this), props);",
         "setHandle(this, handle);",
         "setWrapper(handle, this);",
     ].join("\n");
+
     return renderBlock(`constructor(props: ${PROPS_RECORD} = {})`, body);
 };
 
@@ -71,12 +91,18 @@ const renderTranslatingConstructor = (context: ModuleContext, props: GirProperty
     context.addRuntimeImport("t");
     const destructured = props.map((property) => toCamelIdentifier(property.name));
     const pattern = `{ ${[...destructured, "...rest"].join(", ")} }`;
-    const entries = props.map(
-        (property) =>
-            `${sourceStringLiteral(property.name)}: [${renderDescriptor(context, property.type, property.transferOwnership)}, ${toCamelIdentifier(property.name)}],`,
-    );
+
+    const entries = props.map((property) => {
+        const descriptor = renderDescriptor(context, property.type, property.transferOwnership);
+
+        return `${sourceStringLiteral(property.name)}: [${descriptor}, ${toCamelIdentifier(property.name)}],`;
+    });
+
     const recordLiteral = renderBraced(entries.join("\n"));
     const lines = [`const props: ${PROPS_RECORD} = ${recordLiteral};`, "super({ ...props, ...rest });"];
     const body = lines.join("\n");
+
     return renderBlock(`constructor(${pattern}: ${className}ConstructorProps = {})`, body);
 };
+
+export { renderConstructorPropsInterface, renderClassConstructor };

package/src/store/gi/enum.ts

@@ -4,46 +4,61 @@ import type { ModuleContext } from "../../writer/context.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { indent } from "../../writer/emit.js";
 
-export const generateEnum = (context: ModuleContext, enumeration: GirEnum): void => {
-    if (!enumeration.introspectable) return;
+const generateEnum = (context: ModuleContext, enumeration: GirEnum): void => {
+    if (!enumeration.introspectable) {
+        return;
+    }
+
     const name = enumeration.name;
-    const memberKeys = enumeration.members.map((member) => enumMemberKey(member.name));
+    const members = enumeration.members.map((member) => ({ ...member, key: enumMemberKey(member.name) }));
+
     if (enumeration.errorDomain !== undefined) {
-        const memberEntries = enumeration.members.map((member, index) => `${memberKeys[index]}: ${member.value}`);
-        const typeFields = memberKeys.map((key) => `${key}: number`).join("; ");
+        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(", ")} });`,
+            `export const ${name}: ErrorDomain<{ ${typeFields} }> = ` +
+            `createErrorDomain(${quarkExpression}, { ${memberEntries.join(", ")} });`,
         );
+
         return;
     }
-    if (enumeration.members.some((member) => member.doc !== undefined)) {
-        const memberBlocks = enumeration.members.map(
-            (member, index) => `${renderJsDoc(member.doc)}${memberKeys[index]} = ${member.value},`,
-        );
+
+    if (members.some((member) => member.doc !== undefined)) {
+        const memberBlocks = members.map((member) => `${renderJsDoc(member.doc)}${member.key} = ${member.value},`);
+
         context.module.appendDeclaration(
             `${renderJsDoc(enumeration.doc)}export enum ${name} {\n${indent(memberBlocks.join("\n"), 1)}\n}`,
         );
+
         return;
     }
-    const memberDeclarations = enumeration.members.map((member, index) => `${memberKeys[index]} = ${member.value}`);
+
+    const memberDeclarations = members.map((member) => `${member.key} = ${member.value}`);
+
     context.module.appendDeclaration(
         `${renderJsDoc(enumeration.doc)}export enum ${name} { ${memberDeclarations.join(", ")} }`,
     );
 };
 
-export const enumMemberKey = (name: string): string => {
+const enumMemberKey = (name: string): string => {
     const upper = name.toUpperCase().replaceAll("-", "_");
-    return /^[0-9]/.test(upper) ? `_${upper}` : upper;
+
+    return /^\d/.test(upper) ? `_${upper}` : upper;
 };
 
 const renderQuarkExpression = (context: ModuleContext, errorDomain: string): string => {
     if (context.namespace.name === "GLib") {
         return `() => quarkFromString(${sourceStringLiteral(errorDomain)})`;
     }
+
     const alias = context.addCrossNamespaceImport("GLib");
+
     return `() => ${alias}.quarkFromString(${sourceStringLiteral(errorDomain)})`;
 };
+
+export { generateEnum, enumMemberKey };

package/src/store/gi/function.ts

@@ -1,13 +1,13 @@
 import { toCamelIdentifier } from "@gtkx/utils";
-import { tFn } from "../../analysis/descriptor.js";
-import { hasCallerAllocatedArrayLength } from "../../analysis/param-structure.js";
 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 { arrayLiteral, renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
-import { callableReferencesClassStruct } from "./class-struct-record.js";
+import { hasClassStructReference } from "./class-struct-record.js";
 import {
     planCallArgs,
     renderMethodBody,
@@ -18,32 +18,73 @@ import {
     renderReturnDescriptor,
 } from "./method.js";
 
-export const renderFnExpression = (context: ModuleContext, fn: GirFunction): string | undefined => {
-    if (fn.cIdentifier === undefined) return undefined;
+const renderFnExpression = (context: ModuleContext, fn: GirFunction): string | undefined => {
+    if (fn.cIdentifier === undefined) {
+        return undefined;
+    }
+
     const library = context.namespace.sharedLibrary;
-    if (library === undefined) return undefined;
+
+    if (library === undefined) {
+        return undefined;
+    }
+
     context.addRuntimeImport("t");
     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 });
 };
 
-const namespaceFunctionEmittable = (context: ModuleContext, fn: GirFunction): boolean =>
+// `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(".") ?? [];
+
+    if (typeName === undefined || memberName === undefined) {
+        return false;
+    }
+
+    const resolved = context.library.resolveType(context.namespace.name, typeName);
+
+    if (resolved?.kind !== "class" && resolved?.kind !== "interface" && resolved?.kind !== "record") {
+        return false;
+    }
+
+    const members = [...resolved.value.methods, ...resolved.value.functions, ...resolved.value.constructors];
+
+    return members.some((member) => member.name === memberName);
+};
+
+const canEmitNamespaceFunction = (context: ModuleContext, fn: GirFunction): boolean =>
     fn.introspectable &&
+    !isMovedOntoEmittedMember(context, fn) &&
     fn.shadowedBy === undefined &&
     fn.cIdentifier !== undefined &&
-    !callableReferencesClassStruct(context, fn) &&
+    !hasClassStructReference(context, fn) &&
     !hasCallerAllocatedArrayLength(context.library, fn);
 
-export const generateNamespaceFunction = (context: ModuleContext, fn: GirFunction): void => {
-    if (!namespaceFunctionEmittable(context, fn)) return;
+const generateNamespaceFunction = (context: ModuleContext, fn: GirFunction): void => {
+    if (!canEmitNamespaceFunction(context, fn)) {
+        return;
+    }
+
     const expression = renderFnExpression(context, fn);
-    if (expression === undefined) return;
+
+    if (expression === undefined) {
+        return;
+    }
+
     const cIdentifier = fn.cIdentifier;
-    if (cIdentifier === undefined) return;
+
+    if (cIdentifier === undefined) {
+        return;
+    }
+
     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}`);
@@ -57,51 +98,76 @@ const renderNamespaceFunctionDeclaration = (
 ): string => {
     const finishFn = matchAsyncFinish(context.library, fn, context.namespace.functions);
     const finishCIdentifier = finishFn?.cIdentifier;
-    if (finishFn !== undefined && finishCIdentifier !== undefined && namespaceFunctionEmittable(context, finishFn)) {
+
+    if (finishFn !== undefined && finishCIdentifier !== undefined && canEmitNamespaceFunction(context, finishFn)) {
         const finishExport = namespaceFunctionExportName(
             finishCIdentifier,
             finishFn.name,
             context.namespace.cSymbolPrefixes,
         );
+
         const { signature, returnType } = renderPromisifiedSignature(context, fn, finishFn);
         const body = renderPromisifiedBody(context, fn, finishExport, bindingName);
+
         return renderBlock(`export function ${exportName}(${signature}): ${returnType}`, body);
     }
+
     const signature = renderMethodSignature(context, fn);
     const returnType = renderMethodReturnType(context, fn);
     const body = renderMethodBody(context, fn, { bindingExpression: bindingName });
+
     return renderBlock(`export function ${exportName}(${signature}): ${returnType}`, body);
 };
 
-export const namespaceFunctionExportName = (cIdentifier: string, girName: string, symbolPrefixes: string[]): string => {
+const namespaceFunctionExportName = (cIdentifier: string, girName: string, symbolPrefixes: string[]): string => {
     if (girName.length > 0) {
         return toCamelIdentifier(girName);
     }
+
     const stripped = stripLongestPrefix(cIdentifier, symbolPrefixes);
+
     return toCamelIdentifier(stripped);
 };
 
 const stripLongestPrefix = (input: string, prefixes: string[]): string => {
     let best = "";
+
     for (const prefix of prefixes) {
         const candidate = `${prefix}_`;
+
         if (input.startsWith(candidate) && candidate.length > best.length) {
             best = candidate;
         }
     }
+
     return best.length === 0 ? input : input.slice(best.length);
 };
 
-export const generateNamespaceBootstrap = (context: ModuleContext, namespace: GirNamespace): void => {
+const isBootstrapFunction = (fn: GirFunction): boolean =>
+    fn.parameters.length === 0 && fn.introspectable && fn.shadowedBy === undefined && fn.cIdentifier !== undefined;
+
+const appendBootstrapRegistration = (context: ModuleContext, fn: GirFunction, exportName: string): void => {
+    if (fn.name === "init") {
+        context.module.appendRegistration(`${exportName}();`);
+
+        return;
+    }
+
+    if (fn.name === "finalize") {
+        context.addRuntimeImport("onExit");
+        context.module.appendRegistration(`onExit(${exportName});`);
+    }
+};
+
+const generateNamespaceBootstrap = (context: ModuleContext, namespace: GirNamespace): void => {
     for (const fn of namespace.functions) {
-        if (fn.parameters.length > 0) continue;
-        if (!fn.introspectable || fn.shadowedBy !== undefined || fn.cIdentifier === undefined) continue;
-        const exportName = namespaceFunctionExportName(fn.cIdentifier, fn.name, context.namespace.cSymbolPrefixes);
-        if (fn.name === "init") {
-            context.module.appendRegistration(`${exportName}();`);
-        } else if (fn.name === "finalize") {
-            context.addRuntimeImport("onExit");
-            context.module.appendRegistration(`onExit(${exportName});`);
+        if (!isBootstrapFunction(fn) || fn.cIdentifier === undefined) {
+            continue;
         }
+
+        const exportName = namespaceFunctionExportName(fn.cIdentifier, fn.name, context.namespace.cSymbolPrefixes);
+        appendBootstrapRegistration(context, fn, exportName);
     }
 };
+
+export { renderFnExpression, generateNamespaceFunction, namespaceFunctionExportName, generateNamespaceBootstrap };

package/src/store/gi/gtype-binding.ts

@@ -1,33 +1,46 @@
 import { sourceStringLiteral } from "@gtkx/utils";
-import { PRIMITIVE_TS_TYPE } from "../../gir/primitives.js";
 import type { ModuleContext } from "../../writer/context.js";
+import { PRIMITIVE_TS_TYPE } from "../../gir/primitives.js";
+
+type TypeSource = {
+    glibGetType: string | undefined;
+    glibTypeName: string | undefined;
+};
 
-export const gtypeTsType = (context: ModuleContext): string =>
+const gtypeTsType = (context: ModuleContext): string =>
     context.namespace.name === "GObject" ? "Type" : PRIMITIVE_TS_TYPE.gtype;
 
-export const gtypeMemberDeclaration = (context: ModuleContext): string => `declare __type__: ${gtypeTsType(context)};`;
+const gtypeMemberDeclaration = (context: ModuleContext): string => `declare __type__: ${gtypeTsType(context)};`;
 
-const renderGtypeExpression = (
-    context: ModuleContext,
-    getType: string,
-    typeName: string | undefined,
-): string | undefined => {
-    if (getType === "intern") {
-        if (typeName === undefined) return undefined;
-        if (context.namespace.name !== "GObject") context.addRuntimeImport("typeFromName");
-        return `typeFromName(${sourceStringLiteral(typeName)})`;
+const renderInternGtype = (context: ModuleContext, typeName: string | undefined): string | undefined => {
+    if (typeName === undefined) {
+        return undefined;
+    }
+
+    if (context.namespace.name !== "GObject") {
+        context.addRuntimeImport("typeFromName");
     }
+
+    return `typeFromName(${sourceStringLiteral(typeName)})`;
+};
+
+const renderResolveGtype = (context: ModuleContext, typeFnName: string): string => {
     context.addRuntimeImport("resolveType");
     const lib = context.namespace.sharedLibrary ?? "";
-    return `resolveType(${sourceStringLiteral(lib)}, ${sourceStringLiteral(getType)})`;
-};
 
-type TypeSource = {
-    glibGetType: string | undefined;
-    glibTypeName: string | undefined;
+    return `resolveType(${sourceStringLiteral(lib)}, ${sourceStringLiteral(typeFnName)})`;
 };
 
-export const gtypeExprFor = (context: ModuleContext, source: TypeSource): string | undefined =>
+const renderGtypeExpression = (
+    context: ModuleContext,
+    typeFnName: string,
+    typeName: string | undefined,
+): string | undefined =>
+    typeFnName === "intern" ? renderInternGtype(context, typeName) : renderResolveGtype(context, typeFnName);
+
+const renderSourceGtype = (context: ModuleContext, source: TypeSource): string | undefined =>
     source.glibGetType === undefined
         ? undefined
         : renderGtypeExpression(context, source.glibGetType, source.glibTypeName);
+
+export { gtypeTsType, gtypeMemberDeclaration, renderSourceGtype };

package/src/store/gi/interface.ts

@@ -1,20 +1,21 @@
-import { toPascalCase } from "@gtkx/utils";
-import { reservedSignalMemberRename, resolvePrerequisiteReference } from "../../analysis/inheritance.js";
+import { pascalCase } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
 import type { GirFunction } from "../../gir/function.js";
 import type { ModuleContext } from "../../writer/context.js";
+import { reservedSignalMemberRename, resolvePrerequisiteReference } from "../../analysis/inheritance.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
 import {
     type Callables,
     dedupeCallables,
     generateBindings,
-    indexMethodsByName,
+    type InstanceScope,
+    instanceScope,
     renderClassInstanceMember,
     renderInstanceMethodSignature,
     renderStaticHead,
 } from "./callables.js";
-import { gtypeExprFor } from "./gtype-binding.js";
+import { renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import {
     type PropertyAccessorArgs,
@@ -25,24 +26,59 @@ import { appendInterfaceRegistration } from "./registration.js";
 import { renderSignalDeclarations, renderSignalMembers } from "./signal.js";
 import { renderVfuncMetadata } from "./vtable.js";
 
-export const generateInterface = (context: ModuleContext, iface: GirClass): void => {
-    if (!iface.introspectable) return;
-    if (iface.name.length === 0) return;
-    const className = toPascalCase(iface.name);
+type InterfaceMemberRenderers = {
+    renderMethod: (
+        context: ModuleContext,
+        callable: GirFunction,
+        scope: InstanceScope,
+        nameOverride?: string,
+    ) => string | undefined;
+    renderProperty: (args: PropertyAccessorArgs) => string | undefined;
+};
+
+type MethodMemberOptions = {
+    context: ModuleContext;
+    className: string;
+    scope: InstanceScope;
+    callables: Callables;
+    renderers: InterfaceMemberRenderers;
+    claimedNames: Set<string>;
+};
+
+type PropertyMemberOptions = {
+    context: ModuleContext;
+    iface: GirClass;
+    scope: InstanceScope;
+    renderers: InterfaceMemberRenderers;
+    claimedNames: Set<string>;
+};
+
+const generateInterface = (context: ModuleContext, iface: GirClass): void => {
+    if (!iface.introspectable) {
+        return;
+    }
+
+    if (iface.name.length === 0) {
+        return;
+    }
+
+    const className = pascalCase(iface.name);
+
     const callables: Callables = {
         constructors: dedupeCallables(iface.constructors),
         functions: dedupeCallables(iface.functions),
         methods: dedupeCallables(iface.methods),
     };
-    generateBindings(context, callables);
-
-    const gtypeExpr = gtypeExprFor(context, iface);
 
+    generateBindings(context, callables);
+    const gtypeExpr = renderSourceGtype(context, iface);
     context.module.appendDeclaration(renderInterfaceType(context, iface, className, callables));
     context.module.appendDeclaration(renderInterfaceClass(context, className, callables, gtypeExpr));
+
     for (const declaration of renderSignalDeclarations(context, iface, className, true)) {
         context.module.appendDeclaration(declaration);
     }
+
     context.module.appendDeclaration(renderInterfaceMaker(context, iface, className, callables));
 
     appendInterfaceRegistration(context, {
@@ -59,7 +95,11 @@ const interfaceTypeExtends = (context: ModuleContext, iface: GirClass): string =
     const refs = iface.prerequisites
         .map((name) => resolvePrerequisiteReference(context, name))
         .filter((entry): entry is string => entry !== undefined);
-    if (refs.length > 0) return refs.join(", ");
+
+    if (refs.length > 0) {
+        return refs.join(", ");
+    }
+
     return context.qualify("GObject", "Object");
 };
 
@@ -70,46 +110,62 @@ const renderInterfaceType = (
     callables: Callables,
 ): string => {
     const members = renderInterfaceTypeMembers(context, iface, callables);
+
     return `${renderJsDoc(iface.doc)}${renderBracedOrEmpty(
         `export interface ${className} extends ${interfaceTypeExtends(context, iface)}`,
         members.join("\n"),
     )}`;
 };
 
-type InterfaceMemberRenderers = {
-    renderMethod: (
-        context: ModuleContext,
-        callable: GirFunction,
-        methodByName: Map<string, GirFunction>,
-        nameOverride?: string,
-    ) => string | undefined;
-    renderProperty: (args: PropertyAccessorArgs) => string | undefined;
-};
-
-const renderInterfaceMembers = (
-    context: ModuleContext,
-    iface: GirClass,
-    callables: Callables,
-    renderers: InterfaceMemberRenderers,
-): string[] => {
-    const className = toPascalCase(iface.name);
+const collectMethodMembers = (options: MethodMemberOptions): string[] => {
+    const { context, className, scope, callables, renderers, claimedNames } = options;
     const members: string[] = [];
-    const claimedNames = new Set<string>();
-    const methodByName = indexMethodsByName(callables.methods);
+
     for (const callable of callables.methods) {
         const rename = reservedSignalMemberRename(className, callable);
-        const block = renderers.renderMethod(context, callable, methodByName, rename);
-        if (block === undefined) continue;
+        const block = renderers.renderMethod(context, callable, scope, rename);
+
+        if (block === undefined) {
+            continue;
+        }
+
         members.push(block);
         claimedNames.add(rename ?? methodExportName(callable));
     }
+
+    return members;
+};
+
+const collectPropertyMembers = (options: PropertyMemberOptions): string[] => {
+    const { context, iface, scope, renderers, claimedNames } = options;
+    const members: string[] = [];
+
     for (const property of iface.properties) {
-        const block = renderers.renderProperty({ context, property, claimedNames, methodByName });
-        if (block !== undefined) members.push(block);
+        const block = renderers.renderProperty({ context, property, claimedNames, methodByName: scope.methodByName });
+
+        if (block !== undefined) {
+            members.push(block);
+        }
     }
+
     return members;
 };
 
+const renderInterfaceMembers = (
+    context: ModuleContext,
+    iface: GirClass,
+    callables: Callables,
+    renderers: InterfaceMemberRenderers,
+): string[] => {
+    const className = pascalCase(iface.name);
+    const scope = instanceScope(className, callables);
+    const claimedNames: Set<string> = new Set();
+    const methodMembers = collectMethodMembers({ context, className, scope, callables, renderers, claimedNames });
+    const propertyMembers = collectPropertyMembers({ context, iface, scope, renderers, claimedNames });
+
+    return [...methodMembers, ...propertyMembers];
+};
+
 const renderInterfaceTypeMembers = (context: ModuleContext, iface: GirClass, callables: Callables): string[] =>
     renderInterfaceMembers(context, iface, callables, {
         renderMethod: renderInstanceMethodSignature,
@@ -123,13 +179,19 @@ const renderInterfaceClass = (
     gtypeExpr: string | undefined,
 ): string => {
     const members: string[] = [];
-    if (gtypeExpr !== undefined) members.push(renderInterfaceHasInstance(context, className, gtypeExpr));
+
+    if (gtypeExpr !== undefined) {
+        members.push(renderInterfaceHasInstance(context, className, gtypeExpr));
+    }
+
     members.push(...renderStaticHead(context, callables, className));
+
     return renderBracedOrEmpty(`export abstract class ${className}`, members.join("\n\n"));
 };
 
 const renderInterfaceHasInstance = (context: ModuleContext, className: string, gtypeExpr: string): string => {
     context.addRuntimeImport("valueIsA");
+
     return renderBlock(
         `static [Symbol.hasInstance](value: unknown): value is ${className}`,
         `return valueIsA(value, ${gtypeExpr});`,
@@ -145,6 +207,7 @@ const renderInterfaceMaker = (
     context.addRuntimeTypeImport("Mixin");
     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};`;
 };
 
@@ -155,3 +218,5 @@ const renderInterfaceInstanceMembers = (context: ModuleContext, iface: GirClass,
     }),
     ...renderSignalMembers(context, iface),
 ];
+
+export { generateInterface };