@gtkx/codegen 1.0.0-rc.4 → 1.0.0

package/src/store/gi/pipeline.ts

@@ -5,10 +5,10 @@ import { renderTsType } from "../../analysis/ts-type.js";
 import { PRIMITIVE_TS_TYPE, primitiveCategory } from "../../gir/primitives.js";
 import { splitOptionalNamespace } from "../../gir/type-ref.js";
 import { ModuleContext } from "../../writer/context.js";
-import { renderJsDoc } from "../../writer/doc.js";
 import { generateCallback } from "./callback.js";
 import { generateClass } from "./class.js";
 import { generateConstant } from "./constant.js";
+import { getDoc } from "./doc-spec.js";
 import { generateEnum } from "./enum.js";
 import { generateNamespaceBootstrap, generateNamespaceFunction } from "./function.js";
 import { generateInterface } from "./interface.js";
@@ -72,7 +72,12 @@ const generateNamespaceMembers = (context: ModuleContext, namespace: GirNamespac
 const generateAlias = (context: ModuleContext, alias: GirAlias): void => {
     const category = alias.cType === undefined ? undefined : primitiveCategory(alias.cType);
     const targetType = category === "gtype" ? PRIMITIVE_TS_TYPE.gtype : renderTsType(context, alias.target);
-    context.module.appendDeclaration(`${renderJsDoc(alias.doc)}export type ${alias.name} = ${targetType};`);
+    const doc = getDoc(alias);
+
+    context.module.appendDeclaration(
+        `${doc}export type ${alias.name} = ${targetType};`,
+        context.declaredType(alias.name),
+    );
 };
 
 const visitClass = (state: TopologicalState, klass: GirClass): void => {

package/src/store/gi/properties.ts

@@ -3,11 +3,12 @@ import type { ModuleContext } from "../../writer/context.js";
 import { collectInterfaceProperties } from "../../analysis/inheritance.js";
 import { renderBracedOrEmpty } from "../../writer/emit.js";
 import { parentCompanionRef } from "./companion.js";
-import { type ResolvedAccessor, resolveOwnerAccessor } from "./property-accessor.js";
+import { propertyDoc, type ResolvedAccessor, resolveOwnerAccessor } from "./property-accessor.js";
 
 const PROPERTIES_SUFFIX = "Properties";
 
-const propertyEntry = (accessor: ResolvedAccessor): string => `${accessor.jsName}: ${accessor.tsType};`;
+const propertyEntry = (accessor: ResolvedAccessor): string =>
+    `${propertyDoc(accessor.property)}${accessor.jsName}: ${accessor.tsType};`;
 
 const interfaceEntries = (context: ModuleContext, klass: GirClass): string[] => {
     const entries: string[] = [];

package/src/store/gi/property-accessor.ts

@@ -6,12 +6,13 @@ import { renderDescriptor } from "../../analysis/descriptor-render.js";
 import { inputParameters } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
-import { renderJsDoc } from "../../writer/doc.js";
 import { renderBlock } from "../../writer/emit.js";
 import { isEmittableCallable } from "./callables.js";
+import { getDoc } from "./doc-spec.js";
 import { methodExportName, renderMethodReturnType } from "./method.js";
 
 type ResolvedAccessor = {
+    property: GirProperty;
     jsName: string;
     tsType: string;
     hasGetter: boolean;
@@ -148,7 +149,7 @@ const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefin
     const ownType = resolveOwnType(context, property, getterMethod, setterMethod);
     const tsType = resolveTsType(args.inheritedType, ownType);
 
-    return { jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember };
+    return { property, jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember };
 };
 
 const resolveOwnerAccessor = (
@@ -210,15 +211,18 @@ const renderResolvedPropertyAccessor = (
         blocks.push(renderBlock(`set ${jsName}(value: ${tsType})`, setterBody));
     }
 
-    return `${renderJsDoc(property.doc)}${blocks.join("\n\n")}`;
+    return `${propertyDoc(property)}${blocks.join("\n\n")}`;
 };
 
+const propertyDoc = (property: GirProperty): string =>
+    getDoc(property);
+
 const renderPropertyAccessor = (args: PropertyAccessorArgs): string | undefined =>
     withAccessor(args, (accessor) => renderResolvedPropertyAccessor(args.context, args.property, accessor));
 
 const renderPropertyAccessorSignature = (args: PropertyAccessorArgs): string | undefined =>
     withAccessor(args, ({ jsName, tsType, hasGetter, isWritable }) => {
-        const doc = renderJsDoc(args.property.doc);
+        const doc = propertyDoc(args.property);
 
         if (hasGetter && isWritable) {
             return `${doc}${jsName}: ${tsType};`;
@@ -289,6 +293,7 @@ const delegateMember = (
 };
 
 export {
+    propertyDoc,
     resolveAccessor,
     resolveOwnerAccessor,
     resolveAccessorType,

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

@@ -6,6 +6,7 @@ import type { ModuleContext } from "../../writer/context.js";
 import { renderDescriptor } from "../../analysis/descriptor-render.js";
 import { renderTsType } from "../../analysis/ts-type.js";
 import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
+import { getDoc } from "./doc-spec.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { emitFieldWrite, isEmittableField, isInlineField } from "./record-field-accessor.js";
 import { computeRecordFieldSlots, type RecordFieldSlot } from "./record-layout.js";
@@ -33,7 +34,11 @@ const renderRecordConstructorPropsInterface = (
 
     const lines = slots
         .filter((entry): entry is WritableFieldSlot => isWritableFieldSlot(context, entry))
-        .map((entry) => `${toCamelIdentifier(entry.field.name)}?: ${renderTsType(context, entry.field.type, true)};`);
+        .map(
+            (entry) =>
+                `${getDoc(entry.field)}${toCamelIdentifier(entry.field.name)}?: ` +
+                `${renderTsType(context, entry.field.type, true)};`,
+        );
 
     return renderBracedOrEmpty(head, lines.join("\n"));
 };

package/src/store/gi/record-field-accessor.ts

@@ -1,4 +1,5 @@
 import { toCamelIdentifier } from "@gtkx/utils";
+import type { GirAnnotations } from "../../gir/annotations.js";
 import type { GirField } from "../../gir/field.js";
 import type { FieldSlot } from "../../gir/size.js";
 import type { TypeId } from "../../gir/type-id.js";
@@ -7,8 +8,8 @@ import type { ModuleContext } from "../../writer/context.js";
 import { isInlineCallbackRef, renderDescriptor } from "../../analysis/descriptor-render.js";
 import { tStruct } from "../../analysis/descriptor.js";
 import { renderTsType } from "../../analysis/ts-type.js";
-import { renderJsDoc } from "../../writer/doc.js";
 import { indent, renderBlock } from "../../writer/emit.js";
+import { getDoc } from "./doc-spec.js";
 import { bitMask, computeRecordFieldSlots, mergeBitfield, type RecordFieldSlot } from "./record-layout.js";
 import { wrapReturnValue } from "./return-wrap.js";
 import { isValueMarshalable } from "./value-marshalable.js";
@@ -30,6 +31,7 @@ type RecordFieldEntry = {
     tsType: string;
     isWritable: boolean;
     doc: string | undefined;
+    annotations: GirAnnotations;
 };
 
 type InlineFieldVisit = {
@@ -180,6 +182,7 @@ const resolveRecordFieldEntry = (
         tsType: renderTsType(context, admitted.field.type, false),
         isWritable: admitted.field.writable,
         doc: admitted.field.doc,
+        annotations: admitted.field.annotations,
     };
 };
 
@@ -196,7 +199,7 @@ const renderRecordFieldAccessor = (
     }
 
     const { field, jsName } = admitted;
-    const doc = renderJsDoc(field.doc);
+    const doc = getDoc(field);
     const structArray = renderStructArrayAccessor(context, { field, jsName, slot: slot.slot, siblingFields });
 
     if (structArray !== undefined) {
@@ -632,5 +635,4 @@ export {
     emitFieldWrite,
     resolveRecordFieldEntry,
     renderRecordFieldAccessor,
-    type RecordFieldEntry,
 };

package/src/store/gi/record-layout.ts

@@ -66,7 +66,7 @@ const mergeBitfield = (readExpr: string, valueExpr: string, mask: number, shift:
 
 const fieldLayoutInput = (context: ModuleContext, field: GirField, visited: Set<string>): FieldLayoutInput => {
     if (field.inlineMembers !== undefined) {
-        const layout = inlineMemberLayout(context, field.inlineMembers, field.inlineIsUnion, visited);
+        const layout = inlineMemberLayout(context, field.inlineMembers, field.isInlineUnion, visited);
 
         return { layout, bits: undefined };
     }

package/src/store/gi/record.ts

@@ -1,8 +1,8 @@
 import type { GirRecord } from "../../gir/record.js";
 import type { ModuleContext } from "../../writer/context.js";
-import { renderJsDoc } from "../../writer/doc.js";
 import { indentMembers } from "../../writer/emit.js";
 import { type Callables, dedupeCallables, generateBindings, renderPlainTypeMembers } from "./callables.js";
+import { getDoc } from "./doc-spec.js";
 import { renderSourceGtype } from "./gtype-binding.js";
 import { renderRecordConstructor, renderRecordConstructorPropsInterface } from "./record-constructor.js";
 import { renderRecordFieldAccessor } from "./record-field-accessor.js";
@@ -34,7 +34,13 @@ const generateRecord = (context: ModuleContext, record: GirRecord): void => {
     const members = renderRecordMembers(context, record, className, callables);
     const body = indentMembers(members);
     const heritage = isErrorSubclass ? " extends globalThis.Error" : "";
-    context.module.appendDeclaration(`${renderJsDoc(record.doc)}export class ${className}${heritage} {\n${body}\n}`);
+    const doc = getDoc(record);
+
+    context.module.appendDeclaration(
+        `${doc}export class ${className}${heritage} {\n${body}\n}`,
+        context.declaredType(className),
+    );
+
     context.module.appendDeclaration(renderRecordConstructorPropsInterface(context, record, className));
     const gtypeExpr = renderSourceGtype(context, record);
 

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 = (
@@ -29,7 +29,7 @@ const appendWrapperClassRegistration = (
 };
 
 const appendInterfaceRegistration = (context: ModuleContext, registration: InterfaceRegistration): void => {
-    const { className, makerName, gtypeExpr, vfuncs } = registration;
+    const { className, makerName, gtypeExpr, layout } = registration;
 
     if (gtypeExpr === undefined) {
         return;
@@ -37,7 +37,7 @@ const appendInterfaceRegistration = (context: ModuleContext, registration: Inter
 
     context.addRuntimeImport("registerInterface");
     const base = `${className}, ${gtypeExpr}, ${makerName}`;
-    const args = vfuncs === undefined ? base : `${base}, ${vfuncs}`;
+    const args = layout === undefined ? base : `${base}, ${layout}`;
     context.module.appendRegistration(`registerInterface(${args});`);
 };
 

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

@@ -13,15 +13,16 @@ 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 { getDoc, handlerSpec } from "./doc-spec.js";
 import { isRecordCallerOut, isRecordInout } from "./param-marshal.js";
 
 type SignalMapSpec = {
@@ -117,24 +118,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};`;
     });
 };
 
@@ -342,11 +345,13 @@ const renderCallback = (context: ModuleContext, signal: GirCallable): string =>
         : renderDescriptor(context, signal.returnValue.type, signal.returnValue.transferOwnership);
 
     const callbackArgs = [tObject("borrowed"), ...callbackParamDescriptors, tVoid];
+    const userDataIndex = String(params.length + 1);
+    const destroy = "hasDestroy: true, destroyKind: \"closureNotify\"";
 
     return tCallback(
         callbackArgs,
         returnDescriptor,
-        `{ hasDestroy: true, userDataIndex: ${String(params.length + 1)} }`,
+        `{ ${destroy}, hasUserData: true, userDataIndex: ${userDataIndex} }`,
     );
 };
 
@@ -355,13 +360,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 +419,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 +432,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

@@ -84,4 +84,4 @@ const isValueMarshalable = (context: ModuleContext, namespaceName: string, recor
 const isConstructibleRecord = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
     hasOwnCopySemantics(record) || isValueMarshalable(context, namespaceName, record);
 
-export { hasOwnCopySemantics, isConstructibleRecord, isValueMarshalable };
+export { isConstructibleRecord, isValueMarshalable };