@gtkx/codegen 1.0.0 → 1.2.0

package/src/store/compile-store.ts

@@ -1,50 +1,19 @@
-import { rmSync, writeFileSync } from "node:fs";
+import { rmSync } from "node:fs";
 import { join } from "node:path";
-import { compileProject, type SourceModule } from "../compile.js";
+import { emitModules, type SourceModule } from "../compile.js";
 
 type CompileStoreParams = {
     storeDir: string;
     files: SourceModule[];
     packageName: string;
-    requiresEnvReference?: boolean;
-};
-
-const EMIT_OPTIONS = {
-    declaration: true,
-    removeComments: false,
-    sourceMap: false,
-    declarationMap: false,
-    rootDir: ".",
-    outDir: ".",
-};
-
-const ENV_REFERENCE_FILE = "__gtkx-env__.d.ts";
-
-const writeEnvReference = (storeDir: string): (() => void) => {
-    writeFileSync(join(storeDir, ENV_REFERENCE_FILE), "/// <reference types=\"@gtkx/react/env\" />\n");
-
-    return () => {
-        rmSync(join(storeDir, ENV_REFERENCE_FILE), { force: true });
-    };
 };
 
 const compileStore = (params: CompileStoreParams): void => {
-    const fileNames = params.files.map((file) => file.fileName);
-
-    const removeEnvReference = params.requiresEnvReference === true
-        ? writeEnvReference(params.storeDir)
-        : (): void => undefined;
-
-    try {
-        compileProject({
-            projectDir: params.storeDir,
-            fileNames: params.requiresEnvReference === true ? [ENV_REFERENCE_FILE, ...fileNames] : fileNames,
-            compilerOptions: EMIT_OPTIONS,
-            label: `the generated ${params.packageName} store`,
-        });
-    } finally {
-        removeEnvReference();
-    }
+    emitModules({
+        projectDir: params.storeDir,
+        files: params.files,
+        label: `the generated ${params.packageName} store`,
+    });
 
     for (const file of params.files) {
         rmSync(join(params.storeDir, file.fileName), { force: true });

package/src/store/gi/callables.ts

@@ -1,4 +1,4 @@
-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 type { JsDocSpec } from "../../writer/doc.js";
@@ -10,6 +10,7 @@ import { renderFnExpression } from "./function.js";
 import { gtypeMemberDeclaration } from "./gtype-binding.js";
 import {
     finishCallExpression,
+    memberName,
     methodExportName,
     renderMethodBody,
     renderMethodReturnType,
@@ -49,6 +50,11 @@ type ResolvedInstanceMember = {
     finishFn: GirFunction | undefined;
 };
 
+type StaticMember = {
+    callable: GirFunction;
+    name: string;
+};
+
 type InstanceMemberRenderer = (
     context: ModuleContext,
     callable: GirFunction,
@@ -63,6 +69,15 @@ type PlainTypeMembersOptions = {
     hasGtype: boolean;
 };
 
+const RUNTIME_OWNED_LIFETIME_METHODS: Set<string> = new Set([
+    "force_floating",
+    "free",
+    "ref",
+    "ref_sink",
+    "take_ref",
+    "unref",
+]);
+
 const renderInstanceMethodSignature: InstanceMemberRenderer = instanceMemberRenderer(
     (context, callable, { name, finishFn }) =>
         `${memberDoc(context, callable, finishFn)}${memberSignatureText(context, callable, name, { finishFn })};`,
@@ -99,15 +114,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 (!isEmittableCallable(context, callable)) {
-        return undefined;
-    }
-
-    const cIdentifier = callable.cIdentifier;
+    const cIdentifier = getEmittableCIdentifier(context, callable);
 
     if (cIdentifier === undefined) {
         return undefined;
@@ -139,11 +153,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;
@@ -151,7 +161,7 @@ const resolveCallableMember = (
 
     const name = resolveName(callable);
 
-    if (name === undefined || name === "constructor") {
+    if (name === undefined || !isEmittableMemberName(name)) {
         return undefined;
     }
 
@@ -218,7 +228,7 @@ const renderStaticEntry = (
     if (finishFn !== undefined) {
         const name = options.resolveName(callable);
 
-        if (name === undefined || name === "constructor") {
+        if (name === undefined || !isEmittableMemberName(name)) {
             return undefined;
         }
 
@@ -247,6 +257,8 @@ const renderInstanceMethod = (
         canUseRuntimeOverride: true,
     });
 
+const isEmittableMemberName = (name: string): boolean => name !== "constructor" && name.length > 0;
+
 const resolveInstanceMember = (
     context: ModuleContext,
     callable: GirFunction,
@@ -259,7 +271,7 @@ const resolveInstanceMember = (
 
     const name = nameOverride ?? methodExportName(callable);
 
-    if (name === "constructor") {
+    if (!isEmittableMemberName(name)) {
         return undefined;
     }
 
@@ -370,16 +382,13 @@ const isEmittableCallable = (context: ModuleContext, callable: GirFunction): boo
     callable.introspectable &&
     callable.shadowedBy === undefined &&
     callable.cIdentifier !== undefined &&
+    !RUNTIME_OWNED_LIFETIME_METHODS.has(callable.name) &&
     !hasUnmarshalableParam(context, callable);
 
 const constructorMemberName = (girName: string): string | undefined => {
-    const camel = camelCase(girName);
-
-    if (camel === "constructor") {
-        return undefined;
-    }
+    const camel = memberName(girName);
 
-    return camel;
+    return isEmittableMemberName(camel) ? camel : undefined;
 };
 
 const renderStaticSignature = (
@@ -409,24 +418,43 @@ const renderStaticSignature = (
     };
 };
 
-const classConstructorMemberNames = (context: ModuleContext, callables: Callables): string[] => {
-    const names: string[] = [];
+const staticMemberName = (
+    context: ModuleContext,
+    callable: GirFunction,
+    resolveName: (girName: string) => string | undefined,
+): string | undefined => {
+    if (!isEmittableCallable(context, callable)) {
+        return undefined;
+    }
 
-    for (const callable of callables.constructors) {
-        if (!isEmittableCallable(context, callable)) {
-            continue;
-        }
+    const name = resolveName(callable.name);
+
+    return name !== undefined && isEmittableMemberName(name) ? name : undefined;
+};
+
+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 = staticMemberName(context, callable, resolveName);
 
-        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, memberName),
+    ...collectStaticMembers(context, callables.functions, memberName),
+];
+
 const collectStaticEntries = (
     context: ModuleContext,
     group: GirFunction[],
@@ -456,7 +484,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,
         }),
     ];
@@ -506,12 +534,11 @@ export {
     dedupeCallables,
     generateBindings,
     matchStaticFinishFunction,
-    indexMethodsByName,
     isEmittableCallable,
     renderStaticSignature,
-    classConstructorMemberNames,
     renderStaticHead,
     renderPlainTypeMembers,
+    staticMembers,
     type Callables,
     type InstanceMemberRenderer,
     type InstanceScope,

package/src/store/gi/callback.ts

@@ -1,25 +1,25 @@
+import { sanitizeTypeIdentifier } from "@gtkx/utils";
 import type { ModuleContext } from "../../writer/context.js";
 import { callbackAsFunction, type GirCallback } from "../../gir/callback.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(
-        `${callableDoc(context, fn)}export type ${callback.name} = (${signature}) => ${returnType};`,
-        context.declaredType(callback.name),
-    );
+    context.declare({
+        name,
+        code: `${callableDoc(context, fn)}export type ${name} = (${signature}) => ${returnType};`,
+        owner: callback.name,
+    });
 };
 
 export { generateCallback };

package/src/store/gi/class.ts

@@ -1,26 +1,36 @@
-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 {
+    areCallablesAssignable,
+    type ClaimedMembers,
+    claimInterfaceMembers,
+    inheritedMembers,
+    interfaceConflicts,
+    omittedKeys,
+    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,
     dedupeCallables,
     generateBindings,
     type InstanceScope,
     instanceScope,
     renderClassInstanceMember,
     renderStaticHead,
+    staticMembers,
 } from "./callables.js";
 import { renderClassConstructor, renderConstructorPropsInterface } from "./constructor-props.js";
 import { getDoc } from "./doc-spec.js";
@@ -37,6 +47,7 @@ type ImplementedRef = {
     makerRef: string;
     interfaceKlass: GirClass;
     interfaceNamespace: string;
+    conflicts: string[];
 };
 
 type MemberDeclarationsOptions = {
@@ -49,6 +60,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 +79,11 @@ type AppendInstanceMethodsOptions = {
 };
 
 const generateClass = (context: ModuleContext, klass: GirClass): void => {
-    if (!klass.introspectable) {
+    if (!isEmittableEntity(klass)) {
         return;
     }
 
-    if (klass.name.length === 0) {
-        return;
-    }
-
-    const className = pascalCase(klass.name);
+    const className = sanitizeTypeIdentifier(klass.name);
 
     const callables: Callables = {
         constructors: dedupeCallables(klass.constructors),
@@ -78,20 +93,26 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
 
     generateBindings(context, callables);
     const parentExpression = resolveParent(context, klass);
-    const extendsClause = renderExtendsClause(context, parentExpression, callables);
+    const extendsClause = renderExtendsClause(context, parentExpression, klass, 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(
-        `${doc}export class ${className}${extendsClause}${implementsClause} {\n${body}\n}`,
-        context.declaredType(className),
-    );
+    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);
@@ -101,11 +122,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);
@@ -122,7 +143,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 = (
@@ -131,7 +156,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);
 
@@ -156,17 +181,18 @@ const renderClassMembers = (
 
     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) {
@@ -204,8 +230,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 => {
@@ -254,23 +285,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;
     }
 
@@ -278,22 +300,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);
@@ -303,35 +337,88 @@ const resolveImplementedRefs = (context: ModuleContext, klass: GirClass): Implem
     return refs;
 };
 
+const classCallables = (klass: GirClass): Callables => ({
+    constructors: klass.constructors,
+    functions: klass.functions,
+    methods: klass.methods,
+});
+
+const resolveParentClass = (context: ModuleContext, klass: GirClass): ResolvedAncestor | undefined => {
+    const parent = getParentRef(klass);
+
+    if (parent === undefined) {
+        return undefined;
+    }
+
+    const resolved = context.library.resolveType(parent.namespaceName ?? context.namespace.name, parent.typeName);
+
+    return resolved?.kind === "class" ? { klass: resolved.value, namespaceName: resolved.namespace.name } : undefined;
+};
+
+const addAncestorStatics = (context: ModuleContext, klass: GirClass, table: Map<string, GirFunction>): void => {
+    const members = staticMembers(context, classCallables(klass));
+
+    for (const member of members) {
+        if (!table.has(member.name)) {
+            table.set(member.name, member.callable);
+        }
+    }
+};
+
+const inheritedStatics = (context: ModuleContext, klass: GirClass): Map<string, GirFunction> => {
+    const table: Map<string, GirFunction> = new Map();
+    const parent = resolveParentClass(context, klass);
+
+    if (parent === undefined) {
+        return table;
+    }
+
+    for (const ancestor of ancestorChain(context.library, parent.klass, parent.namespaceName)) {
+        addAncestorStatics(context, ancestor.klass, table);
+    }
+
+    return table;
+};
+
+const shadowedStaticNames = (context: ModuleContext, klass: GirClass, callables: Callables): string[] => {
+    const inherited = inheritedStatics(context, klass);
+
+    return staticMembers(context, callables)
+        .filter((member) => {
+            const shadowed = inherited.get(member.name);
+
+            return shadowed !== undefined && !areCallablesAssignable(context.library, member.callable, shadowed);
+        })
+        .map((member) => member.name);
+};
+
 const renderExtendsClause = (
     context: ModuleContext,
     parentExpression: string | undefined,
+    klass: GirClass,
     callables: Callables,
 ): string => {
     if (parentExpression === undefined) {
         return "";
     }
 
-    const constructorNames = classConstructorMemberNames(context, callables);
+    const staticNames = shadowedStaticNames(context, klass, callables);
 
-    if (constructorNames.length === 0) {
+    if (staticNames.length === 0) {
         return ` extends ${parentExpression}`;
     }
 
     context.addRuntimeTypeImport("StaticBase");
-    const omitted = constructorNames.map((name) => JSON.stringify(name)).join(" | ");
 
-    return ` extends (${parentExpression} as StaticBase<typeof ${parentExpression}, ${omitted}>)`;
+    return ` extends (${parentExpression} as StaticBase<typeof ${parentExpression}, ${omittedKeys(staticNames)}>)`;
 };
 
 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 };

package/src/store/gi/companion.ts

@@ -1,16 +1,17 @@
-import { pascalCase } from "@gtkx/utils";
+import { sanitizeTypeIdentifier } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
 import type { ModuleContext } from "../../writer/context.js";
-import { splitOptionalNamespace } from "../../gir/type-ref.js";
+import { getParentRef } from "../../gir/ancestry.js";
 
 const parentCompanionRef = (context: ModuleContext, klass: GirClass, suffix: string): string | undefined => {
-    if (klass.parent === undefined) {
+    const parent = getParentRef(klass);
+
+    if (parent === undefined) {
         return undefined;
     }
 
-    const [parentNamespace, typeName] = splitOptionalNamespace(klass.parent);
-    const namespaceName = parentNamespace ?? context.namespace.name;
-    const name = `${pascalCase(typeName)}${suffix}`;
+    const namespaceName = parent.namespaceName ?? context.namespace.name;
+    const name = `${sanitizeTypeIdentifier(parent.typeName)}${suffix}`;
 
     if (namespaceName === context.namespace.name) {
         return name;