@gtkx/codegen 1.0.0-rc.4 → 1.1.0

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

@@ -0,0 +1,102 @@
+import type { GirFunction } from "../../gir/function.js";
+import type { GirCallable } from "../../gir/parameter.js";
+import type { ModuleContext } from "../../writer/context.js";
+import type { JsDocSpec } from "../../writer/doc.js";
+import { shouldOmitPrimaryReturn } from "../../analysis/descriptor-render.js";
+import { nulTerminatedByteParams } from "../../analysis/nul-terminated-bytes.js";
+import {
+    documentedParameters,
+    type InputParameter,
+    parameterIdentifier,
+    renamesWithInstance,
+} from "../../analysis/param-structure.js";
+import { renderJsDoc } from "../../writer/doc.js";
+import { annotationSpec, THROWS_TEXT } from "./doc-spec.js";
+import { isCallbackParameter, returnedOutParameters } from "./method.js";
+
+type CallableDocOptions = {
+    finishFn?: GirFunction | undefined;
+    renames?: Map<string, string> | undefined;
+};
+
+const WHITESPACE_RUN_PATTERN = /\s+/g;
+
+const nulTerminatedNote = (context: ModuleContext, callable: GirCallable): string | undefined => {
+    const parameters = nulTerminatedByteParams(context.library, callable);
+
+    if (parameters.length === 0) {
+        return undefined;
+    }
+
+    const names = parameters.map((parameter) => `\`${parameter.name}\``).join(", ");
+
+    return [
+        `The C function reads ${names} as a NUL-terminated string, so it stops at the`,
+        "first zero byte and drops every byte after it without reporting an error.",
+        "Pass binary data through a `GLib.Bytes` route such as `GLib.Variant.newFromBytes`",
+        "instead.",
+    ].join("\n");
+};
+
+const tupleBullet = (name: string, doc: string | undefined): string | undefined => {
+    const text = (doc ?? "").replaceAll(WHITESPACE_RUN_PATTERN, " ").trim();
+
+    return text.length === 0 ? undefined : `- \`${name}\`: ${text}`;
+};
+
+const tupleReturnsText = (primary: string | undefined, outs: InputParameter[]): string | undefined => {
+    const bullets = [
+        tupleBullet("result", primary),
+        ...outs.map(({ parameter, index }) => tupleBullet(parameterIdentifier(parameter, index), parameter.doc)),
+    ].filter((bullet) => bullet !== undefined);
+
+    return bullets.length === 0 ? undefined : `Tuple of:\n\n${bullets.join("\n")}`;
+};
+
+const returnsText = (context: ModuleContext, fn: GirFunction): string | undefined => {
+    const outs = returnedOutParameters(context, fn);
+    const isPrimaryOmitted = shouldOmitPrimaryReturn(context.library, fn.returnValue);
+    const primary = isPrimaryOmitted ? undefined : fn.returnValue.doc;
+
+    if (outs.length === 0) {
+        return primary;
+    }
+
+    if (isPrimaryOmitted && outs.length === 1) {
+        return outs[0]?.parameter.doc;
+    }
+
+    return tupleReturnsText(primary, outs);
+};
+
+const docIdentifiers = (callable: GirFunction, renames: Map<string, string> | undefined): Map<string, string> => {
+    const identifiers = renamesWithInstance(callable.parameters, callable.instance);
+    const overrides = renames ?? new Map<string, string>();
+
+    for (const [girName, declaredName] of overrides) {
+        identifiers.set(girName, declaredName);
+    }
+
+    return identifiers;
+};
+
+const canCallableThrow = (callable: GirFunction, finishFn: GirFunction | undefined): boolean =>
+    callable.throws || finishFn?.throws === true;
+
+const callableSpec = (context: ModuleContext, callable: GirFunction, options: CallableDocOptions): JsDocSpec => ({
+    ...annotationSpec(callable.annotations),
+    identifiers: docIdentifiers(callable, options.renames),
+    params: documentedParameters(
+        context.library,
+        callable,
+        (parameter) => options.finishFn !== undefined && isCallbackParameter(context, parameter),
+        options.renames,
+    ),
+    returns: returnsText(context, options.finishFn ?? callable),
+    throws: canCallableThrow(callable, options.finishFn) ? THROWS_TEXT : undefined,
+});
+
+const callableDoc = (context: ModuleContext, callable: GirFunction, options: CallableDocOptions = {}): string =>
+    renderJsDoc(callable.doc, nulTerminatedNote(context, callable), callableSpec(context, callable, options));
+
+export { callableDoc, callableSpec };

package/src/store/gi/callables.ts

@@ -1,14 +1,16 @@
-import { camelCase, toCamelIdentifier, uniqBy } from "@gtkx/utils";
+import { toCamelIdentifier, uniqBy } from "@gtkx/utils";
 import type { GirFunction } from "../../gir/function.js";
 import type { ModuleContext } from "../../writer/context.js";
-import { hasCallerAllocatedArrayLength } from "../../analysis/param-structure.js";
-import { renderJsDoc } from "../../writer/doc.js";
+import type { JsDocSpec } from "../../writer/doc.js";
+import { hasUnmarshalableParam } from "../../analysis/param-capability.js";
 import { renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
+import { callableDoc, callableSpec } from "./callable-doc.js";
 import { renderFnExpression } from "./function.js";
 import { gtypeMemberDeclaration } from "./gtype-binding.js";
 import {
     finishCallExpression,
+    memberName,
     methodExportName,
     renderMethodBody,
     renderMethodReturnType,
@@ -16,7 +18,7 @@ import {
     renderPromisifiedBody,
     renderPromisifiedSignature,
 } from "./method.js";
-import { renderRuntimeOverride } from "./runtime-override.js";
+import { renderRuntimeOverride, runtimeOverrideRenames } from "./runtime-override.js";
 
 type Callables = {
     constructors: GirFunction[];
@@ -48,6 +50,11 @@ type ResolvedInstanceMember = {
     finishFn: GirFunction | undefined;
 };
 
+type StaticMember = {
+    callable: GirFunction;
+    name: string;
+};
+
 type InstanceMemberRenderer = (
     context: ModuleContext,
     callable: GirFunction,
@@ -64,7 +71,7 @@ type PlainTypeMembersOptions = {
 
 const renderInstanceMethodSignature: InstanceMemberRenderer = instanceMemberRenderer(
     (context, callable, { name, finishFn }) =>
-        `${renderJsDoc(callable.doc)}${memberSignatureText(context, callable, name, { finishFn })};`,
+        `${memberDoc(context, callable, finishFn)}${memberSignatureText(context, callable, name, { finishFn })};`,
 );
 
 const renderClassInstanceMember: InstanceMemberRenderer = instanceMemberRenderer(
@@ -78,6 +85,12 @@ const renderClassInstanceMember: InstanceMemberRenderer = instanceMemberRenderer
                 }),
 );
 
+const memberDoc = (context: ModuleContext, callable: GirFunction, finishFn: GirFunction | undefined): string =>
+    callableDoc(context, callable, { finishFn });
+
+const instanceMemberSpec = (context: ModuleContext, callable: GirFunction, scope: InstanceScope): JsDocSpec =>
+    callableSpec(context, callable, { finishFn: matchFinishFunction(context, callable, scope) });
+
 const instanceScope = (ownerName: string, callables: Callables): InstanceScope => ({
     ownerName,
     methodByName: indexMethodsByName(callables.methods),
@@ -92,19 +105,14 @@ const dedupeCallables = (callables: GirFunction[]): GirFunction[] =>
         (callable) => callable.cIdentifier,
     );
 
+const getEmittableCIdentifier = (context: ModuleContext, callable: GirFunction): string | undefined =>
+    isEmittableCallable(context, callable) ? callable.cIdentifier : undefined;
+
 const renderBinding = (
     context: ModuleContext,
     callable: GirFunction,
 ): { text: string; cIdentifier: string } | undefined => {
-    if (!callable.introspectable) {
-        return undefined;
-    }
-
-    if (callable.shadowedBy !== undefined) {
-        return undefined;
-    }
-
-    const cIdentifier = callable.cIdentifier;
+    const cIdentifier = getEmittableCIdentifier(context, callable);
 
     if (cIdentifier === undefined) {
         return undefined;
@@ -136,11 +144,7 @@ const resolveCallableMember = (
     callable: GirFunction,
     resolveName: (callable: GirFunction) => string | undefined,
 ): { cIdentifier: string; name: string } | undefined => {
-    if (!isEmittableCallable(context, callable)) {
-        return undefined;
-    }
-
-    const cIdentifier = callable.cIdentifier;
+    const cIdentifier = getEmittableCIdentifier(context, callable);
 
     if (cIdentifier === undefined) {
         return undefined;
@@ -148,7 +152,7 @@ const resolveCallableMember = (
 
     const name = resolveName(callable);
 
-    if (name === undefined || name === "constructor") {
+    if (name === undefined || !isEmittableMemberName(name)) {
         return undefined;
     }
 
@@ -182,7 +186,8 @@ const renderCallableMember = (
     }
 
     const { cIdentifier, name } = resolved;
-    const doc = renderJsDoc(callable.doc);
+    const renames = options.canUseRuntimeOverride === true ? runtimeOverrideRenames(callable) : undefined;
+    const doc = callableDoc(context, callable, { renames });
     const override = runtimeOverrideMember(callable, name, doc, options.canUseRuntimeOverride);
 
     if (override !== undefined) {
@@ -214,7 +219,7 @@ const renderStaticEntry = (
     if (finishFn !== undefined) {
         const name = options.resolveName(callable);
 
-        if (name === undefined || name === "constructor") {
+        if (name === undefined || !isEmittableMemberName(name)) {
             return undefined;
         }
 
@@ -243,6 +248,8 @@ const renderInstanceMethod = (
         canUseRuntimeOverride: true,
     });
 
+const isEmittableMemberName = (name: string): boolean => name !== "constructor" && name.length > 0;
+
 const resolveInstanceMember = (
     context: ModuleContext,
     callable: GirFunction,
@@ -255,7 +262,7 @@ const resolveInstanceMember = (
 
     const name = nameOverride ?? methodExportName(callable);
 
-    if (name === "constructor") {
+    if (!isEmittableMemberName(name)) {
         return undefined;
     }
 
@@ -349,7 +356,7 @@ const renderPromisifiedCallable = (
     const prefix = member.isStatic ? "static " : "";
     const header = `${prefix}${member.name}(${signature}): ${returnType}`;
 
-    return `${renderJsDoc(callable.doc)}${renderBlock(header, body)}`;
+    return `${memberDoc(context, callable, finishFn)}${renderBlock(header, body)}`;
 };
 
 const indexMethodsByName = (methods: GirFunction[]): Map<string, GirFunction> => {
@@ -366,16 +373,12 @@ const isEmittableCallable = (context: ModuleContext, callable: GirFunction): boo
     callable.introspectable &&
     callable.shadowedBy === undefined &&
     callable.cIdentifier !== undefined &&
-    !hasCallerAllocatedArrayLength(context.library, callable);
+    !hasUnmarshalableParam(context, callable);
 
 const constructorMemberName = (girName: string): string | undefined => {
-    const camel = camelCase(girName);
+    const camel = memberName(girName);
 
-    if (camel === "constructor") {
-        return undefined;
-    }
-
-    return camel;
+    return isEmittableMemberName(camel) ? camel : undefined;
 };
 
 const renderStaticSignature = (
@@ -405,24 +408,32 @@ const renderStaticSignature = (
     };
 };
 
-const classConstructorMemberNames = (context: ModuleContext, callables: Callables): string[] => {
-    const names: string[] = [];
-
-    for (const callable of callables.constructors) {
-        if (!isEmittableCallable(context, callable)) {
-            continue;
-        }
+const collectStaticMembers = (
+    context: ModuleContext,
+    group: GirFunction[],
+    resolveName: (girName: string) => string | undefined,
+): StaticMember[] => {
+    const members: StaticMember[] = [];
 
-        const member = constructorMemberName(callable.name);
+    for (const callable of group) {
+        const name = isEmittableCallable(context, callable) ? resolveName(callable.name) : undefined;
 
-        if (member !== undefined) {
-            names.push(member);
+        if (name !== undefined) {
+            members.push({ callable, name });
         }
     }
 
-    return names;
+    return members;
 };
 
+const staticMembers = (context: ModuleContext, callables: Callables): StaticMember[] => [
+    ...collectStaticMembers(context, callables.constructors, constructorMemberName),
+    ...collectStaticMembers(context, callables.functions, memberName),
+];
+
+const constructorMemberNames = (context: ModuleContext, constructors: GirFunction[]): string[] =>
+    collectStaticMembers(context, constructors, constructorMemberName).map((member) => member.name);
+
 const collectStaticEntries = (
     context: ModuleContext,
     group: GirFunction[],
@@ -452,7 +463,7 @@ const renderStaticHead = (context: ModuleContext, callables: Callables, ownerCla
             returnTypeOverride: ownerClassName,
         }),
         ...collectStaticEntries(context, callables.functions, siblings, {
-            resolveName: (member) => camelCase(member.name),
+            resolveName: (member) => memberName(member.name),
             ownerName: ownerClassName,
         }),
     ];
@@ -497,6 +508,7 @@ const renderPlainTypeMembers = (
 export {
     renderInstanceMethodSignature,
     renderClassInstanceMember,
+    instanceMemberSpec,
     instanceScope,
     dedupeCallables,
     generateBindings,
@@ -504,9 +516,11 @@ export {
     indexMethodsByName,
     isEmittableCallable,
     renderStaticSignature,
-    classConstructorMemberNames,
+    constructorMemberNames,
     renderStaticHead,
     renderPlainTypeMembers,
+    staticMembers,
     type Callables,
+    type InstanceMemberRenderer,
     type InstanceScope,
 };

package/src/store/gi/callback.ts

@@ -1,24 +1,25 @@
+import { sanitizeTypeIdentifier } from "@gtkx/utils";
 import type { ModuleContext } from "../../writer/context.js";
 import { callbackAsFunction, type GirCallback } from "../../gir/callback.js";
-import { renderJsDoc } from "../../writer/doc.js";
+import { isEmittableEntity } from "../../gir/emittable.js";
+import { callableDoc } from "./callable-doc.js";
 import { renderMethodReturnType, renderMethodSignature } from "./method.js";
 
 const generateCallback = (context: ModuleContext, callback: GirCallback): void => {
-    if (!callback.introspectable) {
-        return;
-    }
-
-    if (callback.name.length === 0) {
+    if (!isEmittableEntity(callback)) {
         return;
     }
 
     const fn = callbackAsFunction(callback);
     const signature = renderMethodSignature(context, fn);
     const returnType = renderMethodReturnType(context, fn);
+    const name = sanitizeTypeIdentifier(callback.name);
 
-    context.module.appendDeclaration(
-        `${renderJsDoc(callback.doc)}export type ${callback.name} = (${signature}) => ${returnType};`,
-    );
+    context.declare({
+        name,
+        code: `${callableDoc(context, fn)}export type ${name} = (${signature}) => ${returnType};`,
+        owner: callback.name,
+    });
 };
 
 export { generateCallback };

package/src/store/gi/class.ts

@@ -1,21 +1,28 @@
-import { pascalCase, toCamelIdentifier } from "@gtkx/utils";
+import { sanitizeTypeIdentifier, toCamelIdentifier } 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 {
+    ancestorClassMethodNames,
     collectInheritedMethods,
     collectInheritedPropertyTypes,
     collectInterfaceMergeOmissions,
     conflictRename,
     type InheritedMethods,
 } from "../../analysis/inheritance.js";
-import { ancestorChain, type ResolvedAncestor } from "../../gir/ancestry.js";
-import { splitOptionalNamespace } from "../../gir/type-ref.js";
-import { renderJsDoc } from "../../writer/doc.js";
+import {
+    type ClaimedMembers,
+    claimInterfaceMembers,
+    inheritedMembers,
+    interfaceConflicts,
+    omittedTypeRef,
+} from "../../analysis/interface-conflicts.js";
+import { ancestorChain, getParentRef, type ResolvedAncestor } from "../../gir/ancestry.js";
+import { isEmittableEntity } from "../../gir/emittable.js";
 import { indentMembers } from "../../writer/emit.js";
 import {
     type Callables,
-    classConstructorMemberNames,
+    constructorMemberNames,
     dedupeCallables,
     generateBindings,
     type InstanceScope,
@@ -24,19 +31,21 @@ import {
     renderStaticHead,
 } from "./callables.js";
 import { renderClassConstructor, renderConstructorPropsInterface } from "./constructor-props.js";
+import { getDoc } from "./doc-spec.js";
 import { gtypeMemberDeclaration, renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import { renderPropertyDeclarations } from "./properties.js";
 import { renderResolvedPropertyAccessor, resolveAccessor, type ResolvedAccessor } from "./property-accessor.js";
 import { appendWrapperClassRegistration } from "./registration.js";
 import { renderSignalDeclarations, renderSignalMembers } from "./signal.js";
-import { renderVfuncMetadata } from "./vtable.js";
+import { renderVfuncMembers, renderVfuncMetadata } from "./vtable.js";
 
 type ImplementedRef = {
     typeRef: string;
     makerRef: string;
     interfaceKlass: GirClass;
     interfaceNamespace: string;
+    conflicts: string[];
 };
 
 type MemberDeclarationsOptions = {
@@ -49,6 +58,14 @@ type MemberDeclarationsOptions = {
 
 type ClassMembers = { members: string[]; accessors: ResolvedAccessor[] };
 
+type ImplementedRefOptions = {
+    context: ModuleContext;
+    klass: GirClass;
+    name: string;
+    inherited: Set<string>;
+    claimed: ClaimedMembers;
+};
+
 type AppendInstanceMethodsOptions = {
     context: ModuleContext;
     methods: GirFunction[];
@@ -60,15 +77,11 @@ type AppendInstanceMethodsOptions = {
 };
 
 const generateClass = (context: ModuleContext, klass: GirClass): void => {
-    if (!klass.introspectable) {
-        return;
-    }
-
-    if (klass.name.length === 0) {
+    if (!isEmittableEntity(klass)) {
         return;
     }
 
-    const className = pascalCase(klass.name);
+    const className = sanitizeTypeIdentifier(klass.name);
 
     const callables: Callables = {
         constructors: dedupeCallables(klass.constructors),
@@ -80,16 +93,24 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
     const parentExpression = resolveParent(context, klass);
     const extendsClause = renderExtendsClause(context, parentExpression, callables);
     const implemented = resolveImplementedRefs(context, klass);
-    const typeRefs = implemented.map((ref) => ref.typeRef);
+    const typeRefs = implemented.map((ref) => omittedTypeRef(ref.typeRef, ref.conflicts));
     const implementsClause = typeRefs.length === 0 ? "" : ` implements ${typeRefs.join(", ")}`;
     const { members, accessors } = renderClassMembers(context, klass, callables, parentExpression !== undefined);
     const body = indentMembers(members);
+    const doc = getDoc(klass);
+    const modifier = klass.isAbstract ? "abstract " : "";
+
+    context.declare({
+        name: className,
+        code: `${doc}export ${modifier}class ${className}${extendsClause}${implementsClause} {\n${body}\n}`,
+        owner: klass.name,
+    });
 
-    context.module.appendDeclaration(
-        `${renderJsDoc(klass.doc)}export class ${className}${extendsClause}${implementsClause} {\n${body}\n}`,
-    );
+    context.declare({
+        name: `${className}ConstructorProps`,
+        code: renderConstructorPropsInterface(context, klass, className),
+    });
 
-    context.module.appendDeclaration(renderConstructorPropsInterface(context, klass, className));
     appendMemberDeclarations({ context, klass, className, accessors, implemented });
     appendInstallMixins(context, className, implemented);
     appendClassRegistrations(context, klass, className);
@@ -99,11 +120,11 @@ const appendMemberDeclarations = (options: MemberDeclarationsOptions): void => {
     const { context, klass, className, accessors, implemented } = options;
 
     for (const declaration of renderPropertyDeclarations(context, klass, className, accessors)) {
-        context.module.appendDeclaration(declaration);
+        context.declare(declaration);
     }
 
     for (const declaration of renderSignalDeclarations(context, klass, className, false)) {
-        context.module.appendDeclaration(declaration);
+        context.declare(declaration);
     }
 
     appendInterfaceMerge(context, klass, className, implemented);
@@ -120,7 +141,11 @@ const appendInterfaceMerge = (
     }
 
     const mergeRefs = implemented.map((ref) => interfaceMergeRef(context, klass, ref));
-    context.module.appendDeclaration(`export interface ${className} extends ${mergeRefs.join(", ")} {}`);
+
+    context.declare({
+        name: className,
+        code: `export interface ${className} extends ${mergeRefs.join(", ")} {}`,
+    });
 };
 
 const renderClassMembers = (
@@ -129,7 +154,7 @@ const renderClassMembers = (
     callables: Callables,
     hasParent: boolean,
 ): ClassMembers => {
-    const className = pascalCase(klass.name);
+    const className = sanitizeTypeIdentifier(klass.name);
     const members: string[] = [gtypeMemberDeclaration(context)];
     const constructorBlock = renderClassConstructor(context, klass, className, hasParent);
 
@@ -152,18 +177,21 @@ const renderClassMembers = (
         className,
     });
 
+    members.push(...renderVfuncMembers({ context, klass, mode: "implementation" }));
     const inheritedPropertyTypes = collectInheritedPropertyTypes(context, klass);
+    const inheritedNames = ancestorClassMethodNames(context, klass);
     const accessors: ResolvedAccessor[] = [];
 
     for (const property of klass.properties) {
-        const inheritedType = inheritedPropertyTypes.get(toCamelIdentifier(property.name));
+        const inheritedTypes = inheritedPropertyTypes.get(toCamelIdentifier(property.name));
 
         const accessor = resolveAccessor({
             context,
             property,
             claimedNames,
             methodByName: scope.methodByName,
-            inheritedType,
+            inheritedTypes,
+            inheritedNames,
         });
 
         if (accessor === undefined) {
@@ -201,8 +229,13 @@ const appendInstallMixins = (context: ModuleContext, className: string, implemen
     }
 
     context.addRuntimeImport("installMixins");
-    const makers = implemented.map((ref) => ref.makerRef).join(", ");
-    context.module.appendRegistration(`installMixins(${className}, [${makers}]);`);
+    const makerRefs = implemented.map((ref) => ref.makerRef);
+    const localRefs = makerRefs.filter((ref) => !ref.includes("."));
+
+    context.module.appendRegistration(`installMixins(${className}, [${makerRefs.join(", ")}]);`, [
+        className,
+        ...localRefs,
+    ]);
 };
 
 const appendClassRegistrations = (context: ModuleContext, klass: GirClass, className: string): void => {
@@ -251,23 +284,14 @@ const interfaceMergeRef = (context: ModuleContext, klass: GirClass, ref: Impleme
         namespaceName: ref.interfaceNamespace,
     });
 
-    if (omissions.length === 0) {
-        return ref.typeRef;
-    }
-
-    const keys = omissions.map((name) => JSON.stringify(name)).join(" | ");
-
-    return `Omit<${ref.typeRef}, ${keys}>`;
+    return omittedTypeRef(ref.typeRef, [...omissions, ...ref.conflicts]);
 };
 
-const implementedRefFor = (
-    context: ModuleContext,
-    name: string,
-    inherited: Set<string>,
-): ImplementedRef | undefined => {
+const implementedRefFor = (options: ImplementedRefOptions): ImplementedRef | undefined => {
+    const { context, klass, name, inherited } = options;
     const resolved = context.library.resolveType(context.namespace.name, name);
 
-    if (resolved?.kind !== "interface") {
+    if (resolved?.kind !== "interface" || !isEmittableEntity(resolved.value)) {
         return undefined;
     }
 
@@ -275,22 +299,34 @@ const implementedRefFor = (
         return undefined;
     }
 
-    const pascal = pascalCase(resolved.value.name);
+    const typeName = sanitizeTypeIdentifier(resolved.value.name);
+
+    const conflictOptions = {
+        context,
+        klass,
+        iface: resolved.value,
+        ifaceNamespace: resolved.namespace.name,
+    };
+
+    const conflicts = interfaceConflicts(conflictOptions, options.claimed);
+    claimInterfaceMembers(conflictOptions, options.claimed);
 
     return {
-        typeRef: context.qualify(resolved.namespace.name, pascal),
-        makerRef: context.qualify(resolved.namespace.name, `make${pascal}`),
+        typeRef: context.qualify(resolved.namespace.name, typeName),
+        makerRef: context.qualify(resolved.namespace.name, `make${typeName}`),
         interfaceKlass: resolved.value,
         interfaceNamespace: resolved.namespace.name,
+        conflicts,
     };
 };
 
 const resolveImplementedRefs = (context: ModuleContext, klass: GirClass): ImplementedRef[] => {
     const inherited = inheritedInterfaceKeys(context, klass);
+    const claimed = inheritedMembers(context, klass);
     const refs: ImplementedRef[] = [];
 
     for (const name of klass.implements) {
-        const ref = implementedRefFor(context, name, inherited);
+        const ref = implementedRefFor({ context, klass, name, inherited, claimed });
 
         if (ref !== undefined) {
             refs.push(ref);
@@ -309,7 +345,7 @@ const renderExtendsClause = (
         return "";
     }
 
-    const constructorNames = classConstructorMemberNames(context, callables);
+    const constructorNames = constructorMemberNames(context, callables.constructors);
 
     if (constructorNames.length === 0) {
         return ` extends ${parentExpression}`;
@@ -322,13 +358,11 @@ const renderExtendsClause = (
 };
 
 const resolveParent = (context: ModuleContext, klass: GirClass): string | undefined => {
-    if (klass.parent === undefined) {
-        return undefined;
-    }
-
-    const [namespace, typeName] = splitOptionalNamespace(klass.parent);
+    const parent = getParentRef(klass);
 
-    return context.qualify(namespace ?? context.namespace.name, pascalCase(typeName));
+    return parent === undefined
+        ? undefined
+        : context.qualify(parent.namespaceName ?? context.namespace.name, sanitizeTypeIdentifier(parent.typeName));
 };
 
 export { generateClass };