@gtkx/codegen 1.2.0 → 1.2.2

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

@@ -1,6 +1,7 @@
 import { toCamelIdentifier } from "@gtkx/utils";
 import type { GirAnnotations } from "../../gir/annotations.js";
 import type { GirField } from "../../gir/field.js";
+import type { PrimitiveCategory } from "../../gir/primitives.js";
 import type { GirRecord } from "../../gir/record.js";
 import type { FieldSlot } from "../../gir/size.js";
 import type { TypeId } from "../../gir/type-id.js";
@@ -9,9 +10,16 @@ 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 { isByteSequence, isUnboundedArray } from "../../analysis/type-shape.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 {
+    bitMask,
+    computeRecordFieldSlots,
+    inlineArrayStride,
+    mergeBitfield,
+    type RecordFieldSlot,
+} from "./record-layout.js";
 import { wrapReturnValue } from "./return-wrap.js";
 import { isValueMarshalable } from "./value-marshalable.js";
 
@@ -27,6 +35,10 @@ type AdmittedField = {
     jsName: string;
 };
 
+type AccessibleField = AdmittedField & {
+    isSettable: boolean;
+};
+
 type RecordFieldEntry = {
     jsName: string;
     tsType: string;
@@ -94,6 +106,22 @@ type AccessorOptions = {
     fieldType: TypeId;
 };
 
+type InlineArrayResolution = {
+    element: TypeId;
+    count: number;
+    stride: number;
+    isTypedByteArray: boolean;
+};
+
+type InlineArrayAccessorOptions = {
+    context: ModuleContext;
+    jsName: string;
+    tsType: string;
+    descriptor: string;
+    offset: number;
+    resolution: InlineArrayResolution;
+};
+
 const isMarshalableField = (context: ModuleContext, field: GirField): boolean => {
     if (field.cType?.endsWith("*") === true) {
         return true;
@@ -167,12 +195,52 @@ const admitField = (
     return { field, jsName };
 };
 
+const isNullTerminatedArrayField = (context: ModuleContext, ref: TypeId): boolean => {
+    const type = context.library.typeFor(ref);
+
+    return type?.kind === "carray" && isUnboundedArray(type) && type.elementCType?.endsWith("*") === true;
+};
+
+const isAccessibleFieldType = (context: ModuleContext, ref: TypeId): boolean =>
+    isAccessorEligibleType(context, ref) || isNullTerminatedArrayField(context, ref);
+
+const isStorableFieldType = (context: ModuleContext, ref: TypeId): boolean => {
+    const kind = context.library.typeFor(ref)?.kind;
+
+    return kind !== "carray" && kind !== "list" && kind !== "hashtable";
+};
+
+const hasArrayAccessor = (context: ModuleContext, target: StructArrayTarget): boolean =>
+    resolveInlineArray(context, target) !== undefined || resolveStructArray(context, target) !== undefined;
+
+const admitAccessibleField = (
+    context: ModuleContext,
+    slot: RecordFieldSlot,
+    claimedNames: Set<string>,
+    siblingFields: GirField[],
+): AccessibleField | undefined => {
+    const admitted = admitField(context, slot, claimedNames);
+
+    if (admitted === undefined) {
+        return undefined;
+    }
+
+    const { field, jsName } = admitted;
+    const target: StructArrayTarget = { field, jsName, slot: slot.slot, siblingFields };
+    const hasArray = hasArrayAccessor(context, target);
+    const hasAccessor = hasArray || isAccessibleFieldType(context, field.type);
+    const isSettable = field.writable && (hasArray || isStorableFieldType(context, field.type));
+
+    return hasAccessor ? { ...admitted, isSettable } : undefined;
+};
+
 const resolveRecordFieldEntry = (
     context: ModuleContext,
     slot: RecordFieldSlot,
     claimedNames: Set<string>,
+    siblingFields: GirField[],
 ): RecordFieldEntry | undefined => {
-    const admitted = admitField(context, slot, claimedNames);
+    const admitted = admitAccessibleField(context, slot, claimedNames, siblingFields);
 
     if (admitted === undefined) {
         return undefined;
@@ -181,7 +249,7 @@ const resolveRecordFieldEntry = (
     return {
         jsName: admitted.jsName,
         tsType: renderTsType(context, admitted.field.type, false),
-        isWritable: admitted.field.writable,
+        isWritable: admitted.isSettable,
         doc: admitted.field.doc,
         annotations: admitted.field.annotations,
     };
@@ -193,7 +261,7 @@ const renderRecordFieldAccessor = (
     claimedNames: Set<string>,
     siblingFields: GirField[],
 ): string | undefined => {
-    const admitted = admitField(context, slot, claimedNames);
+    const admitted = admitAccessibleField(context, slot, claimedNames, siblingFields);
 
     if (admitted === undefined) {
         return undefined;
@@ -201,16 +269,11 @@ const renderRecordFieldAccessor = (
 
     const { field, jsName } = admitted;
     const doc = getDoc(field);
-    const structArray = renderStructArrayAccessor(context, { field, jsName, slot: slot.slot, siblingFields });
-
-    if (structArray !== undefined) {
-        return `${doc}${structArray}`;
-    }
-
-    if (!isAccessorEligibleType(context, field.type)) {
-        const tsType = renderTsType(context, field.type, false);
+    const target: StructArrayTarget = { field, jsName, slot: slot.slot, siblingFields };
+    const arrayAccessor = renderInlineArrayAccessor(context, target) ?? renderStructArrayAccessor(context, target);
 
-        return `${doc}declare ${jsName}: ${tsType};`;
+    if (arrayAccessor !== undefined) {
+        return `${doc}${arrayAccessor}`;
     }
 
     const descriptor = context.hoistDescriptor(
@@ -230,7 +293,7 @@ const renderRecordFieldAccessor = (
 
     const blocks: string[] = [getterBlock(accessorOptions)];
 
-    if (field.writable) {
+    if (admitted.isSettable) {
         blocks.push(setterBlock(accessorOptions));
     }
 
@@ -259,7 +322,7 @@ const isAccessorEligibleType = (context: ModuleContext, ref: TypeId): boolean =>
             return context.library.nameFor(ref) !== undefined;
         }
         case "carray": {
-            return type.fixedSize !== undefined;
+            return type.fixedSize !== undefined && type.arrayCType?.endsWith("*") === true;
         }
         case "list":
         case "hashtable":
@@ -302,15 +365,96 @@ const resolveInlineStructFields = (
     return type.value.fields;
 };
 
+const isInlineScalarCategory = (category: PrimitiveCategory, isBehindPointer: boolean): boolean => {
+    if (category === "pointer") {
+        return true;
+    }
+
+    return !isBehindPointer && category !== "void" && category !== "unichar" && category !== "string";
+};
+
+const isInlineArrayElement = (context: ModuleContext, ref: TypeId | undefined, cType: string | undefined): boolean => {
+    const type = ref === undefined ? undefined : context.library.typeFor(ref);
+
+    if (type === undefined) {
+        return false;
+    }
+
+    const isBehindPointer = cType?.endsWith("*") === true;
+
+    switch (type.kind) {
+        case "primitive": {
+            return isInlineScalarCategory(type.category, isBehindPointer);
+        }
+        case "enum": {
+            return !isBehindPointer;
+        }
+        case "record": {
+            return (
+                resolveInlineStructFields(context, ref, cType) !== undefined &&
+                isValueMarshalable(context, type.namespace.name, type.value)
+            );
+        }
+        case "alias": {
+            return isInlineArrayElement(context, type.value.target, cType ?? type.value.targetCType);
+        }
+        case "callback":
+        case "carray":
+        case "class":
+        case "hashtable":
+        case "interface":
+        case "list":
+        case "varargs": {
+            return false;
+        }
+    }
+};
+
+const inlineArrayType = (
+    context: ModuleContext,
+    target: StructArrayTarget,
+): Extract<GirType, { kind: "carray" }> | undefined => {
+    const { field, slot } = target;
+
+    if (field.type === undefined || slot.bitWidth !== undefined) {
+        return undefined;
+    }
+
+    const type = context.library.typeFor(field.type);
+
+    if (type?.kind !== "carray" || type.fixedSize === undefined) {
+        return undefined;
+    }
+
+    return type.arrayCType?.endsWith("*") === true ? undefined : type;
+};
+
+const resolveInlineArray = (context: ModuleContext, target: StructArrayTarget): InlineArrayResolution | undefined => {
+    const type = inlineArrayType(context, target);
+
+    if (type?.fixedSize === undefined || !isInlineArrayElement(context, type.element, type.elementCType)) {
+        return undefined;
+    }
+
+    const stride = inlineArrayStride(context, type);
+
+    if (stride === 0) {
+        return undefined;
+    }
+
+    return {
+        element: type.element,
+        count: type.fixedSize,
+        stride,
+        isTypedByteArray: context.library.isByteArrayTyped && isByteSequence(context.library, type),
+    };
+};
+
 const arrayLengthExpression = (
     arrayRef: Extract<GirType, { kind: "carray" }>,
     siblingFields: GirField[],
 ): string | undefined => {
-    if (arrayRef.fixedSize !== undefined) {
-        return String(arrayRef.fixedSize);
-    }
-
-    if (arrayRef.lengthParameterIndex === undefined) {
+    if (arrayRef.fixedSize !== undefined || arrayRef.lengthParameterIndex === undefined) {
         return undefined;
     }
 
@@ -570,6 +714,82 @@ const resolveStructArray = (context: ModuleContext, target: StructArrayTarget):
     };
 };
 
+const inlineArrayElementOffset = (options: InlineArrayAccessorOptions): string =>
+    `${String(options.offset)} + __index * ${String(options.resolution.stride)}`;
+
+const inlineArrayGetterBlock = (options: InlineArrayAccessorOptions): string => {
+    const { context, jsName, tsType, descriptor, resolution } = options;
+    const container = resolution.isTypedByteArray ? `new ${tsType}(${String(resolution.count)})` : "[]";
+
+    const element = wrapReturnValue(context, {
+        ref: resolution.element,
+        isNullable: false,
+        valueExpression: `read(getHandle(this), ${descriptor}, ${inlineArrayElementOffset(options)})`,
+    });
+
+    const body = [
+        `const __result: ${tsType} = ${container};`,
+        `for (let __index = 0; __index < ${String(resolution.count)}; __index++) {`,
+        indent(`__result[__index] = ${element};`, 1),
+        "}",
+        "return __result;",
+    ].join("\n");
+
+    return renderBlock(`get ${jsName}(): ${tsType}`, body);
+};
+
+const inlineArraySetterBlock = (options: InlineArrayAccessorOptions): string => {
+    const { jsName, tsType, descriptor, resolution } = options;
+
+    const write =
+        `write(getHandle(this), ${descriptor}, ${inlineArrayElementOffset(options)}, ` +
+        `toNative(${descriptor}, __element));`;
+
+    const body = [
+        "for (const [__index, __element] of __value.entries()) {",
+        indent(`if (__index >= ${String(resolution.count)}) {\n    break;\n}\n\n${write}`, 1),
+        "}",
+    ].join("\n");
+
+    return renderBlock(`set ${jsName}(__value: ${tsType})`, body);
+};
+
+const renderInlineArrayAccessor = (context: ModuleContext, target: StructArrayTarget): string | undefined => {
+    const resolution = resolveInlineArray(context, target);
+
+    if (resolution === undefined) {
+        return undefined;
+    }
+
+    const { field, jsName, slot } = target;
+    context.addRuntimeImport("read");
+    context.addRuntimeImport("getHandle");
+    context.addRuntimeImport("t");
+
+    const options: InlineArrayAccessorOptions = {
+        context,
+        jsName,
+        tsType: renderTsType(context, field.type, false),
+        descriptor: context.hoistDescriptor(renderDescriptor(context, resolution.element, "none", { isInline: true })),
+        offset: slot.byteOffset,
+        resolution,
+    };
+
+    const blocks: string[] = [];
+
+    if (field.readable) {
+        blocks.push(inlineArrayGetterBlock(options));
+    }
+
+    if (field.writable) {
+        context.addRuntimeImport("write");
+        context.addRuntimeImport("toNative");
+        blocks.push(inlineArraySetterBlock(options));
+    }
+
+    return blocks.length === 0 ? undefined : blocks.join("\n\n");
+};
+
 const renderStructArrayAccessor = (context: ModuleContext, target: StructArrayTarget): string | undefined => {
     const resolution = resolveStructArray(context, target);
 
@@ -654,6 +874,7 @@ const setterBlock = (options: AccessorOptions): string =>
 export {
     isEmittableField,
     isInlineField,
+    isStorableFieldType,
     emitFieldWrite,
     resolveRecordFieldEntry,
     renderRecordFieldAccessor,

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

@@ -56,6 +56,9 @@ const recordInlineSize = (context: ModuleContext, record: ResolvedRecordValue):
     return size > 0 ? size : undefined;
 };
 
+const inlineArrayStride = (context: ModuleContext, array: Extract<GirType, { kind: "carray" }>): number =>
+    layoutOfType(context, array.element, array.elementCType, new Set()).size;
+
 const bitMask = (width: number): number => {
     if (width >= 32) {
         return 0xFF_FF_FF_FF;
@@ -224,4 +227,11 @@ const resolveAliasLayout = (
     return layoutOfType(context, ref, resolved.value.targetCType, visited);
 };
 
-export { computeRecordFieldSlots, recordInlineSize, bitMask, mergeBitfield, type RecordFieldSlot };
+export {
+    computeRecordFieldSlots,
+    inlineArrayStride,
+    recordInlineSize,
+    bitMask,
+    mergeBitfield,
+    type RecordFieldSlot,
+};

package/src/store/gi/signal.ts

@@ -1,5 +1,5 @@
 import { camelCase, sourceStringLiteral } from "@gtkx/utils";
-import type { GirClass } from "../../gir/class.js";
+import type { GirClass, GirSignal } from "../../gir/class.js";
 import type { GirCallable, GirParameter, GirReturnValue } from "../../gir/parameter.js";
 import type { GirProperty } from "../../gir/property.js";
 import type { ModuleContext } from "../../writer/context.js";
@@ -139,16 +139,20 @@ const renderSignalMap = (spec: SignalMapSpec): string => {
     const { context, klass, className, isParentlessObjectSubclass, suffix, renderEntry } = spec;
     const extendsRefs = signalMapParentRefs(context, klass, isParentlessObjectSubclass, suffix);
     const extendsClause = extendsRefs.length === 0 ? "" : ` extends ${extendsRefs.join(", ")}`;
+    const signals = collectClassSignals(context, klass);
 
-    const signalEntries = collectClassSignals(context, klass).map(
-        (signal) => `${signalDoc(signal)}${sourceStringLiteral(signal.name)}: ${renderEntry(context, signal)};`,
-    );
+    const signalEntries = signals.flatMap((signal) => {
+        const value = renderEntry(context, signal);
+        const entry = `${signalDoc(signal)}${sourceStringLiteral(signal.name)}: ${value};`;
 
-    const entries = [
-        ...signalEntries,
-        ...renderNotifyDetailEntries(context, klass, suffix),
-        ...renderCustomNotifyEntry(context, klass, suffix),
-    ];
+        if (!signal.isDetailed) {
+            return [entry];
+        }
+
+        return [entry, `[detail: \`${signal.name}::\${string}\`]: ${value};`];
+    });
+
+    const entries = [...signalEntries, ...renderNotifyDetailEntries(context, klass, suffix)];
 
     return renderBracedOrEmpty(`export interface ${className}${suffix}${extendsClause}`, entries.join("\n"));
 };
@@ -156,14 +160,6 @@ const renderSignalMap = (spec: SignalMapSpec): string => {
 const signalDoc = (signal: GirCallable): string =>
     renderJsDoc(signal.doc, undefined, handlerSpec(signal, signal.parameters));
 
-const renderCustomNotifyEntry = (context: ModuleContext, klass: GirClass, suffix: string): string[] => {
-    if (context.namespace.name !== "GObject" || klass.name !== "Object") {
-        return [];
-    }
-
-    return [`[detail: \`notify::\${string}\`]: ${gobjectObjectMapRef(context, suffix)}["notify"];`];
-};
-
 const renderNotifyDetailEntries = (context: ModuleContext, klass: GirClass, suffix: string): string[] => {
     const notifyValue = `${gobjectObjectMapRef(context, suffix)}["notify"]`;
 
@@ -219,10 +215,11 @@ const renderSignalConnectInterface = (className: string, isRootObject: boolean):
         `__signals__?: ${map};`,
         `connect<K extends keyof ${map}>(signal: K, handler: ${map}[K], isAfter?: boolean): number;`,
         `emit<K extends keyof ${emitMap}>(sigName: K, ...args: ${emitMap}[K]["args"]): ${emitMap}[K]["result"];`,
-        "emit(sigName: string, ...args: unknown[]): unknown;",
     ];
 
-    if (!isRootObject) {
+    if (isRootObject) {
+        lines.push("emit(sigName: string, ...args: unknown[]): unknown;");
+    } else {
         const chainable = (methods: string[], trailing: string): void => {
             for (const method of methods) {
                 lines.push(
@@ -382,7 +379,7 @@ const renderCallback = (context: ModuleContext, signal: GirCallable): string =>
 const forEachInterfaceSignal = (
     context: ModuleContext,
     klass: GirClass,
-    consider: (signal: GirCallable) => void,
+    consider: (signal: GirSignal) => void,
 ): void => {
     for (const iface of resolveInterfaces(context.library, context.namespace.name, klass.implements)) {
         for (const signal of iface.klass.signals) {
@@ -391,12 +388,12 @@ const forEachInterfaceSignal = (
     }
 };
 
-const collectClassSignals = (context: ModuleContext, klass: GirClass): GirCallable[] => {
+const collectClassSignals = (context: ModuleContext, klass: GirClass): GirSignal[] => {
     const inheritedNames = collectInheritedSignalNames(context, klass);
     const seen: Set<string> = new Set();
-    const result: GirCallable[] = [];
+    const result: GirSignal[] = [];
 
-    const consider = (signal: GirCallable): void => {
+    const consider = (signal: GirSignal): void => {
         const name = camelCase(signal.name);
 
         if (!signal.introspectable || inheritedNames.has(name) || seen.has(name)) {

package/src/store/resolve-store.ts

@@ -28,6 +28,7 @@ const STORE_CONSUMERS: string[] = [
     "@gtkx/components",
     "@gtkx/css",
     "@gtkx/react",
+    "@gtkx/runtime",
     "@gtkx/testing",
 ];