@gtkx/codegen 1.0.0-rc.4 → 1.1.0

package/src/store/gi/registration.ts

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

package/src/store/gi/runtime-override.ts

@@ -5,6 +5,7 @@ type RuntimeOverride = {
     signature: string;
     returnType: string;
     body: string;
+    renames?: [string, string][];
 };
 
 const RUNTIME_OVERRIDES: Map<string, RuntimeOverride> = new Map([
@@ -23,16 +24,22 @@ const RUNTIME_OVERRIDES: Map<string, RuntimeOverride> = new Map([
             signature: "boxed: object | null",
             returnType: "void",
             body: 'throw new Error("g_value_set_boxed: runtime override not installed");',
+            renames: [["v_boxed", "boxed"]],
         },
     ],
 ]);
 
-const renderRuntimeOverride = (callable: GirFunction, memberName: string): string | undefined => {
-    if (callable.cIdentifier === undefined) {
-        return undefined;
-    }
+const runtimeOverrideFor = (callable: GirFunction): RuntimeOverride | undefined =>
+    callable.cIdentifier === undefined ? undefined : RUNTIME_OVERRIDES.get(callable.cIdentifier);
+
+const runtimeOverrideRenames = (callable: GirFunction): Map<string, string> | undefined => {
+    const renames = runtimeOverrideFor(callable)?.renames;
 
-    const override = RUNTIME_OVERRIDES.get(callable.cIdentifier);
+    return renames === undefined ? undefined : new Map(renames);
+};
+
+const renderRuntimeOverride = (callable: GirFunction, memberName: string): string | undefined => {
+    const override = runtimeOverrideFor(callable);
 
     if (override === undefined) {
         return undefined;
@@ -43,4 +50,4 @@ const renderRuntimeOverride = (callable: GirFunction, memberName: string): strin
     return `${memberName}${generics}(${override.signature}): ${override.returnType} {\n    ${override.body}\n}`;
 };
 
-export { renderRuntimeOverride };
+export { renderRuntimeOverride, runtimeOverrideRenames };

package/src/store/gi/signal.ts

@@ -1,28 +1,30 @@
 import { camelCase, sourceStringLiteral } from "@gtkx/utils";
 import type { GirClass } from "../../gir/class.js";
-import type { GirCallable, GirParameter } from "../../gir/parameter.js";
+import type { GirCallable, GirParameter, GirReturnValue } from "../../gir/parameter.js";
 import type { GirProperty } from "../../gir/property.js";
 import type { ModuleContext } from "../../writer/context.js";
+import type { Declaration } from "../../writer/module.js";
 import {
     isCellInout,
+    primaryReturnKind,
     renderDescriptor,
     renderParamDescriptor,
-    shouldOmitPrimaryReturn,
 } from "../../analysis/descriptor-render.js";
 import { tCallback, tObject, tVoid } from "../../analysis/descriptor.js";
 import {
     collectInterfaceProperties,
     forEachAncestor,
-    resolveImplementedInterface,
     resolvePrerequisiteReference,
 } from "../../analysis/inheritance.js";
 import { renderHandlerParameters, renderHandlerResultType } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
+import { resolveInterfaces } from "../../gir/ancestry.js";
 import { isCallerAllocatedOut, isOutParameter } from "../../gir/parameter.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { indent, renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
 import { parentCompanionRef } from "./companion.js";
-import { isRecordCallerOut, isRecordInout } from "./param-marshal.js";
+import { getDoc, handlerSpec } from "./doc-spec.js";
+import { isAllocatableCallerOut, isRecordInout, renderCallerOutInstance } from "./param-marshal.js";
 
 type SignalMapSpec = {
     context: ModuleContext;
@@ -91,12 +93,18 @@ const renderSignalDeclarations = (
     klass: GirClass,
     className: string,
     isParentlessObjectSubclass: boolean,
-): string[] => {
+): Declaration[] => {
     const base = { context, klass, className, isParentlessObjectSubclass };
 
-    const declarations = [
-        renderSignalMap({ ...base, suffix: SIGNALS_SUFFIX, renderEntry: renderSignalHandlerType }),
-        renderSignalMap({ ...base, suffix: SIGNAL_EMIT_SUFFIX, renderEntry: renderSignalEmitEntry }),
+    const declarations: Declaration[] = [
+        {
+            name: `${className}${SIGNALS_SUFFIX}`,
+            code: renderSignalMap({ ...base, suffix: SIGNALS_SUFFIX, renderEntry: renderSignalHandlerType }),
+        },
+        {
+            name: `${className}${SIGNAL_EMIT_SUFFIX}`,
+            code: renderSignalMap({ ...base, suffix: SIGNAL_EMIT_SUFFIX, renderEntry: renderSignalEmitEntry }),
+        },
     ];
 
     if (
@@ -106,7 +114,7 @@ const renderSignalDeclarations = (
             klass.implements.length > 0)
     ) {
         const isRootObject = context.namespace.name === "GObject" && klass.name === "Object";
-        declarations.push(renderSignalConnectInterface(className, isRootObject));
+        declarations.push({ name: className, code: renderSignalConnectInterface(className, isRootObject) });
     }
 
     return declarations;
@@ -117,24 +125,26 @@ const renderSignalMap = (spec: SignalMapSpec): string => {
     const extendsRefs = signalMapParentRefs(context, klass, isParentlessObjectSubclass, suffix);
     const extendsClause = extendsRefs.length === 0 ? "" : ` extends ${extendsRefs.join(", ")}`;
 
-    const signalEntries = collectClassSignals(context, klass).map((signal) => {
-        const entry = `${sourceStringLiteral(signal.name)}: ${renderEntry(context, signal)};`;
-
-        return suffix === SIGNALS_SUFFIX ? `${renderJsDoc(signal.doc)}${entry}` : entry;
-    });
+    const signalEntries = collectClassSignals(context, klass).map(
+        (signal) => `${signalDoc(signal)}${sourceStringLiteral(signal.name)}: ${renderEntry(context, signal)};`,
+    );
 
     const entries = [...signalEntries, ...renderNotifyDetailEntries(context, klass, suffix)];
 
     return renderBracedOrEmpty(`export interface ${className}${suffix}${extendsClause}`, entries.join("\n"));
 };
 
+const signalDoc = (signal: GirCallable): string =>
+    renderJsDoc(signal.doc, undefined, handlerSpec(signal, signal.parameters));
+
 const renderNotifyDetailEntries = (context: ModuleContext, klass: GirClass, suffix: string): string[] => {
     const notifyValue = `${gobjectObjectMapRef(context, suffix)}["notify"]`;
 
-    return collectNotifyDetails(context, klass).map((name) => {
-        const detailedSignal = `notify::${name}`;
+    return collectNotifyDetails(context, klass).map((property) => {
+        const detailedSignal = `notify::${property.name}`;
+        const doc = getDoc(property);
 
-        return `${sourceStringLiteral(detailedSignal)}: ${notifyValue};`;
+        return `${doc}${sourceStringLiteral(detailedSignal)}: ${notifyValue};`;
     });
 };
 
@@ -260,7 +270,7 @@ const renderEmitArgLiteral = (options: EmitArgOptions): { literal: string; nextA
     }
 
     if (isCallerAllocatedOut(parameter)) {
-        const value = renderCallerOutAllocation(context, parameter);
+        const value = renderCallerOutInstance(context, parameter);
 
         return {
             literal: `{ type: ${descriptor}, direction: "out", isCallerAllocated: true, value: ${value} }`,
@@ -280,10 +290,18 @@ const renderEmitArgLiteral = (options: EmitArgOptions): { literal: string; nextA
     return { literal: `{ type: ${descriptor}, value: args[${String(argIndex)}] }`, nextArgIndex: argIndex + 1 };
 };
 
+const renderEmitReturnArg = (context: ModuleContext, returnValue: GirReturnValue): string => {
+    if (primaryReturnKind(context.library, returnValue) === "void") {
+        return "";
+    }
+
+    return `, ${renderDescriptor(context, returnValue.type, returnValue.transferOwnership)}`;
+};
+
 const renderEmitCase = (context: ModuleContext, signal: GirCallable): string => {
     const params = nonVarargParameters(signal);
 
-    if (params.some((parameter) => isCallerAllocatedOut(parameter) && !isRecordCallerOut(context, parameter))) {
+    if (params.some((parameter) => isCallerAllocatedOut(parameter) && !isAllocatableCallerOut(context, parameter))) {
         return renderUnsupportedEmitCase(signal);
     }
 
@@ -298,12 +316,7 @@ const renderEmitCase = (context: ModuleContext, signal: GirCallable): string =>
         return rendered.literal;
     });
 
-    const isVoid = shouldOmitPrimaryReturn(context.library, signal.returnValue);
-
-    const returnArg = isVoid
-        ? ""
-        : `, ${renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership)}`;
-
+    const returnArg = renderEmitReturnArg(context, signal.returnValue);
     const body = `return emitSignal(this, sigName, [${argLiterals.join(", ")}]${returnArg});`;
 
     return renderBlock(`case ${sourceStringLiteral(signal.name)}:`, body);
@@ -318,16 +331,6 @@ const renderUnsupportedEmitCase = (signal: GirCallable): string => {
     );
 };
 
-const renderCallerOutAllocation = (context: ModuleContext, parameter: GirParameter): string => {
-    const name = parameter.type === undefined ? undefined : context.library.nameFor(parameter.type);
-
-    if (name === undefined) {
-        throw new Error("renderCallerOutAllocation: expected a named caller-allocated out-parameter");
-    }
-
-    return `new ${context.qualify(name.namespaceName, name.typeName)}()`;
-};
-
 const renderCallback = (context: ModuleContext, signal: GirCallable): string => {
     const params = nonVarargParameters(signal);
 
@@ -335,19 +338,19 @@ const renderCallback = (context: ModuleContext, signal: GirCallable): string =>
         renderParamDescriptor(context, parameter, parameter.type, { argIndexOffset: 1 }),
     );
 
-    const isVoid = shouldOmitPrimaryReturn(context.library, signal.returnValue);
-
-    const returnDescriptor = isVoid
-        ? tVoid
-        : renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership);
-
     const callbackArgs = [tObject("borrowed"), ...callbackParamDescriptors, tVoid];
-
-    return tCallback(
-        callbackArgs,
-        returnDescriptor,
-        `{ hasDestroy: true, userDataIndex: ${String(params.length + 1)} }`,
-    );
+    const userDataIndex = String(params.length + 1);
+
+    return tCallback({
+        argTypes: callbackArgs,
+        returns: renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership),
+        options: [
+            "hasDestroy: true",
+            "destroyKind: \"closureNotify\"",
+            "hasUserData: true",
+            `userDataIndex: ${userDataIndex}`,
+        ],
+    });
 };
 
 const forEachInterfaceSignal = (
@@ -355,13 +358,7 @@ const forEachInterfaceSignal = (
     klass: GirClass,
     consider: (signal: GirCallable) => void,
 ): void => {
-    for (const implementName of klass.implements) {
-        const iface = resolveImplementedInterface(context, implementName);
-
-        if (iface === undefined) {
-            continue;
-        }
-
+    for (const iface of resolveInterfaces(context.library, context.namespace.name, klass.implements)) {
         for (const signal of iface.klass.signals) {
             consider(signal);
         }
@@ -420,10 +417,10 @@ const collectInheritedMemberNames = (
 const collectInheritedSignalNames = (context: ModuleContext, klass: GirClass): Set<string> =>
     collectInheritedMemberNames(context, klass, (source) => source.signals);
 
-const collectNotifyDetails = (context: ModuleContext, klass: GirClass): string[] => {
+const collectNotifyDetails = (context: ModuleContext, klass: GirClass): GirProperty[] => {
     const inherited = collectInheritedMemberNames(context, klass, (source) => source.properties);
     const seen: Set<string> = new Set();
-    const result: string[] = [];
+    const result: GirProperty[] = [];
 
     const consider = (property: GirProperty): void => {
         const name = camelCase(property.name);
@@ -433,7 +430,7 @@ const collectNotifyDetails = (context: ModuleContext, klass: GirClass): string[]
         }
 
         seen.add(name);
-        result.push(property.name);
+        result.push(property);
     };
 
     for (const property of klass.properties) {

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

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