@gtkx/codegen 1.2.1 → 1.3.0

package/src/store/gi/method.ts

@@ -20,6 +20,7 @@ import {
     parameterIdentifier,
 } from "../../analysis/param-structure.js";
 import { renderParameterTsType, renderTsType } from "../../analysis/ts-type.js";
+import { primitiveCategoryFor } from "../../analysis/type-shape.js";
 import { type GirParameter, isCallerAllocatedOut, isInoutParameter, isOutParameter } from "../../gir/parameter.js";
 import { hasUnknownArrayLength, type TypeId } from "../../gir/type-id.js";
 import { areClosuresInvoked } from "./closure-invocation.js";
@@ -27,8 +28,10 @@ import { itemComparatorArgDescriptors, itemComparatorTsType } from "./item-compa
 import {
     isClosureType,
     isCollectibleCallerOut,
+    isFixedArrayCallerOut,
     isHandlePassedInPlace,
     isHandlePassing,
+    isValueType,
     renderCallerOutInstance,
 } from "./param-marshal.js";
 
@@ -44,6 +47,14 @@ type CallExpressionOptions = {
     isForcedNullable?: boolean | undefined;
 };
 
+type MarshalledArgumentOptions = {
+    context: ModuleContext;
+    ref: TypeId;
+    name: string;
+    isNullable: boolean;
+    isValueMarshalled: boolean;
+};
+
 type PromisifyContext = {
     context: ModuleContext;
     asyncFn: GirFunction;
@@ -64,12 +75,15 @@ type CallArgPlan = {
 type ReturnDescriptorPlan = {
     descriptor: string;
     isSkipped: boolean;
+    isUnpacked: boolean;
 };
 
 type ParamDescriptorOptions = {
     direction?: "out" | "inout";
     isCallerAllocated?: boolean;
     isConsumed?: boolean;
+    isUnpacked?: boolean;
+    isRequired?: boolean;
 };
 
 type ArgIndexOptions = {
@@ -113,6 +127,9 @@ const requiresClosureMarshal = (context: ModuleContext, fn: GirFunction, ref: Ty
 const requiresClosureAnnotation = (context: ModuleContext, fn: GirFunction, parameter: GirParameter): boolean =>
     parameter.type !== undefined && requiresClosureMarshal(context, fn, parameter.type);
 
+const isValueRead = (parameter: GirParameter): boolean =>
+    !isInoutParameter(parameter) && parameter.cType?.includes("const ") === true;
+
 const parameterAnnotation = (context: ModuleContext, fn: GirFunction, parameter: GirParameter): string => {
     const comparator = itemComparatorTsType(context, fn, parameter);
 
@@ -120,7 +137,7 @@ const parameterAnnotation = (context: ModuleContext, fn: GirFunction, parameter:
         return comparator;
     }
 
-    const base = renderParameterTsType(context, parameter.type, parameter.nullable);
+    const base = renderParameterTsType(context, parameter.type, parameter.nullable, isValueRead(parameter));
 
     return requiresClosureAnnotation(context, fn, parameter) ? closureAnnotation(context, base) : base;
 };
@@ -153,10 +170,14 @@ const renderInputParameters = (context: ModuleContext, fn: GirFunction, options:
     return parts.join(", ");
 };
 
+const isInPlaceInout = (context: ModuleContext, parameter: GirParameter): boolean =>
+    context.library.isInoutInPlace && isInoutParameter(parameter) && isHandlePassedInPlace(context, parameter);
+
 const isReturnedOutParameter = (context: ModuleContext, parameter: GirParameter): boolean =>
     isOutParameter(parameter) ||
-    (isCallerAllocatedOut(parameter) && isCollectibleCallerOut(context, parameter)) ||
-    isInoutParameter(parameter);
+    (isCallerAllocatedOut(parameter) &&
+        (isCollectibleCallerOut(context, parameter) || isFixedArrayCallerOut(context, parameter))) ||
+        (isInoutParameter(parameter) && !isInPlaceInout(context, parameter));
 
 const returnedOutParameters = (context: ModuleContext, fn: GirFunction): InputParameter[] => {
     const folded = foldedLengthIndices(context.library, fn);
@@ -171,18 +192,34 @@ const returnedOutParameters = (context: ModuleContext, fn: GirFunction): InputPa
     return result;
 };
 
+const isUnwrappedValue = (context: ModuleContext, ref: TypeId | undefined): boolean =>
+    context.library.isValueUnwrapped && ref !== undefined && isValueType(context, ref);
+
+const renderReturnedTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable: boolean): string =>
+    isUnwrappedValue(context, ref) ? "unknown" : renderTsType(context, ref, isNullable);
+
+const isUnpackedOutParameter = (context: ModuleContext, parameter: GirParameter): boolean =>
+    isCallerAllocatedOut(parameter) &&
+    isCollectibleCallerOut(context, parameter) &&
+    isUnwrappedValue(context, parameter.type);
+
+const renderOutTsType = (context: ModuleContext, parameter: GirParameter): string =>
+    isUnpackedOutParameter(context, parameter)
+        ? "unknown"
+        : renderTsType(context, parameter.type, parameter.nullable);
+
 const renderMethodReturnType = (context: ModuleContext, fn: GirFunction): string => {
     const outs = returnedOutParameters(context, fn);
 
     const primary = shouldOmitPrimaryReturn(context.library, fn.returnValue)
         ? undefined
-        : renderTsType(context, fn.returnValue.type, fn.returnValue.nullable);
+        : renderReturnedTsType(context, fn.returnValue.type, fn.returnValue.nullable);
 
     if (outs.length === 0) {
         return primary ?? "void";
     }
 
-    const outTypes = outs.map(({ parameter }) => renderTsType(context, parameter.type, parameter.nullable));
+    const outTypes = outs.map(({ parameter }) => renderOutTsType(context, parameter));
 
     return foldOutParamShape(primary, outTypes);
 };
@@ -240,13 +277,35 @@ const renderCancellableExpression = (parameters: GirParameter[], cancellableInde
     return parameter === undefined ? "null" : parameterIdentifier(parameter, cancellableIndex);
 };
 
+const shouldTrimFinishBoolean = (context: ModuleContext, finishFn: GirFunction): boolean =>
+    context.library.isFinishTrimmed &&
+    finishFn.throws &&
+    !shouldOmitPrimaryReturn(context.library, finishFn.returnValue) &&
+    primitiveCategoryFor(context.library, finishFn.returnValue.type) === "boolean" &&
+    returnedOutParameters(context, finishFn).length > 0;
+
+const promisifiedFinishExpression = (
+    context: ModuleContext,
+    finishFn: GirFunction,
+    finishExpression: string,
+): string => {
+    if (!shouldTrimFinishBoolean(context, finishFn)) {
+        return finishExpression;
+    }
+
+    context.addRuntimeImport("trimFinish");
+
+    return `trimFinish(${finishExpression})`;
+};
+
 const renderPromisifiedBody = (
     context: ModuleContext,
     asyncFn: GirFunction,
-    finishExpression: string,
+    finishTarget: { fn: GirFunction; expression: string },
     bindingExpression: string,
 ): string => {
     context.addRuntimeImport("promisify");
+    const finish = promisifiedFinishExpression(context, finishTarget.fn, finishTarget.expression);
     const cancellableIndex = findCancellableIndex(context, asyncFn.parameters);
 
     const promisifyContext: PromisifyContext = {
@@ -267,7 +326,7 @@ const renderPromisifiedBody = (
     const cancellableExpression = renderCancellableExpression(asyncFn.parameters, cancellableIndex);
     const leadingArguments = leadingExpressions.length > 0 ? `, ${leadingExpressions.join(", ")}` : "";
 
-    return `return promisify(${bindingExpression}, ${finishExpression}, ${cancellableExpression}${leadingArguments});`;
+    return `return promisify(${bindingExpression}, ${finish}, ${cancellableExpression}${leadingArguments});`;
 };
 
 const finishCallExpression = (asyncFn: GirFunction, finishFn: GirFunction, ownerName: string): string =>
@@ -310,7 +369,12 @@ const renderPromisifiedSignature = (
         isOptionalExtra: (parameter) => isCancellable(context, parameter),
     });
 
-    const finishReturn = renderMethodReturnType(context, finishFn);
+    const finishReturn = shouldTrimFinishBoolean(context, finishFn)
+        ? foldOutParamShape(
+                undefined,
+                returnedOutParameters(context, finishFn).map(({ parameter }) => renderOutTsType(context, parameter)),
+            )
+        : renderMethodReturnType(context, finishFn);
 
     return { signature, returnType: `Promise<${finishReturn}>` };
 };
@@ -356,6 +420,14 @@ const paramDescriptorLiteral = (descriptor: string, options: ParamDescriptorOpti
         parts.push("isConsumed: true");
     }
 
+    if (options.isUnpacked === true) {
+        parts.push("isUnpacked: true");
+    }
+
+    if (options.isRequired === true) {
+        parts.push("isRequired: true");
+    }
+
     return `{ ${parts.join(", ")} }`;
 };
 
@@ -368,7 +440,11 @@ const renderReturnDescriptor = (context: ModuleContext, fn: GirFunction): Return
         isNewlyCreated: fn.instance === undefined,
     });
 
-    return { descriptor, isSkipped: isSkippedPrimaryReturn(context.library, fn.returnValue) };
+    return {
+        descriptor,
+        isSkipped: isSkippedPrimaryReturn(context.library, fn.returnValue),
+        isUnpacked: isUnwrappedValue(context, fn.returnValue.type),
+    };
 };
 
 const planCallArgs = (context: ModuleContext, fn: GirFunction): CallArgPlan[] => {
@@ -408,6 +484,8 @@ const planCallArgs = (context: ModuleContext, fn: GirFunction): CallArgPlan[] =>
 const isSkippedPlanParameter = (parameter: GirParameter, index: number, closureIndices: Set<number>): boolean =>
     parameter.isVarargs || closureIndices.has(index);
 
+const isRequiredParameter = (parameter: GirParameter): boolean => !parameter.nullable && !parameter.optional;
+
 const planParameter = (
     context: ModuleContext,
     parameter: GirParameter,
@@ -503,18 +581,35 @@ const planCallerOut = (
     parameter: GirParameter,
     argIndex: ArgIndexOptions,
 ): CallArgPlan => {
-    const descriptor = renderDescriptor(context, parameter.type, "none", argIndex);
-
     if (isCollectibleCallerOut(context, parameter)) {
         context.addRuntimeImport("getHandle");
 
         return {
-            paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", isCallerAllocated: true }),
+            paramLiteral: paramDescriptorLiteral(renderDescriptor(context, parameter.type, "none", argIndex), {
+                direction: "out",
+                isCallerAllocated: true,
+                isUnpacked: isUnpackedOutParameter(context, parameter),
+            }),
             inputExpr: renderCallerOutInstance(context, parameter),
         };
     }
 
-    return { paramLiteral: paramDescriptorLiteral(descriptor, {}), inputExpr: "undefined" };
+    if (isFixedArrayCallerOut(context, parameter)) {
+        const descriptor = renderDescriptor(context, parameter.type, "none", {
+            ...argIndex,
+            isCallerAllocated: true,
+        });
+
+        return {
+            paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out" }),
+            inputExpr: undefined,
+        };
+    }
+
+    return {
+        paramLiteral: paramDescriptorLiteral(renderDescriptor(context, parameter.type, "none", argIndex), {}),
+        inputExpr: "undefined",
+    };
 };
 
 const planInoutParam = (
@@ -537,7 +632,8 @@ const planInoutParam = (
             paramLiteral: paramDescriptorLiteral(descriptor, {
                 direction: "inout",
                 isCallerAllocated: true,
-                isConsumed,
+                isConsumed: isConsumed || context.library.isInoutInPlace,
+                isRequired: isRequiredParameter(parameter),
             }),
             inputExpr: parameterIdentifier(parameter, index),
         };
@@ -549,7 +645,11 @@ const planInoutParam = (
     });
 
     return {
-        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "inout", isConsumed }),
+        paramLiteral: paramDescriptorLiteral(descriptor, {
+            direction: "inout",
+            isConsumed,
+            isRequired: lengthSource === undefined && isRequiredParameter(parameter),
+        }),
         inputExpr:
             lengthSource === undefined
                 ? parameterCallExpression(context, parameter, index, { fn })
@@ -582,7 +682,7 @@ const planInParam = (
         );
 
     return {
-        paramLiteral: paramDescriptorLiteral(descriptor, {}),
+        paramLiteral: paramDescriptorLiteral(descriptor, { isRequired: isRequiredParameter(parameter) }),
         inputExpr: parameterCallExpression(context, parameter, index, { fn }),
     };
 };
@@ -602,7 +702,25 @@ const closureArgument = (context: ModuleContext, name: string, isNullable: boole
     return `${helper}(${name})`;
 };
 
-const hashtableArgument = (context: ModuleContext, valueRef: TypeId, name: string): string => {
+const valueArgument = (context: ModuleContext, name: string, isNullable: boolean): string => {
+    const helper = isNullable ? "tryToValueHandle" : "toValueHandle";
+    context.addRuntimeImport(helper);
+
+    return `${helper}(${name})`;
+};
+
+const hashtableArgument = (
+    context: ModuleContext,
+    valueRef: TypeId,
+    name: string,
+    isValueMarshalled: boolean,
+): string => {
+    if (isValueMarshalled && isValueType(context, valueRef)) {
+        context.addRuntimeImport("toValueHandle");
+
+        return `${name} ? globalThis.Array.from(${name}).map(([k, v]) => [k, toValueHandle(v)]) : null`;
+    }
+
     if (isHandlePassing(context, valueRef)) {
         context.addRuntimeImport("getHandle");
 
@@ -612,36 +730,43 @@ const hashtableArgument = (context: ModuleContext, valueRef: TypeId, name: strin
     return `${name} ? globalThis.Array.from(${name}) : null`;
 };
 
-const mapHandleExpression = (name: string, isNullable: boolean): string =>
-    isNullable ? `${name}?.map((item) => getHandle(item))` : `${name}.map((item) => getHandle(item))`;
+const mapItemExpression = (name: string, isNullable: boolean, helper: string): string =>
+    isNullable ? `${name}?.map((item) => ${helper}(item))` : `${name}.map((item) => ${helper}(item))`;
+
+const itemHelper = (context: ModuleContext, element: TypeId, isValueMarshalled: boolean): string => {
+    const helper = isValueMarshalled && isValueType(context, element) ? "toValueHandle" : "getHandle";
+    context.addRuntimeImport(helper);
+
+    return helper;
+};
+
+const collectionArgument = (options: MarshalledArgumentOptions & { type: GirType | undefined }): string | undefined => {
+    const { context, type, name, isNullable, isValueMarshalled } = options;
 
-const collectionArgument = (
-    context: ModuleContext,
-    type: GirType | undefined,
-    name: string,
-    isNullable: boolean,
-): string | undefined => {
     if (type?.kind === "hashtable") {
-        return hashtableArgument(context, type.value, name);
+        return hashtableArgument(context, type.value, name, isValueMarshalled);
     }
 
-    if (!isMappableSequence(context, type)) {
+    const element = mappableElement(context, type);
+
+    if (element === undefined) {
         return undefined;
     }
 
-    context.addRuntimeImport("getHandle");
-
-    return mapHandleExpression(name, isNullable);
+    return mapItemExpression(name, isNullable, itemHelper(context, element, isValueMarshalled));
 };
 
-const isMappableSequence = (context: ModuleContext, type: GirType | undefined): boolean => {
+const mappableElement = (context: ModuleContext, type: GirType | undefined): TypeId | undefined => {
     if (type?.kind === "carray") {
-        return !hasUnknownArrayLength(type) && isHandlePassing(context, type.element);
+        return hasUnknownArrayLength(type) ? undefined : mappableRef(context, type.element);
     }
 
-    return type?.kind === "list" && isHandlePassing(context, type.element);
+    return type?.kind === "list" ? mappableRef(context, type.element) : undefined;
 };
 
+const mappableRef = (context: ModuleContext, element: TypeId): TypeId | undefined =>
+    isHandlePassing(context, element) ? element : undefined;
+
 const parameterCallExpression = (
     context: ModuleContext,
     parameter: GirParameter,
@@ -662,13 +787,40 @@ const parameterCallExpression = (
         return closureArgument(context, name, isNullable);
     }
 
-    if (isHandlePassing(context, ref)) {
-        return handleArgument(context, name, isNullable);
+    const marshalled = marshalledArgument({
+        context,
+        ref,
+        name,
+        isNullable,
+        isValueMarshalled: isValueRead(parameter),
+    });
+
+    if (marshalled !== undefined) {
+        return marshalled;
     }
 
     const type = context.library.typeFor(ref);
 
-    return collectionArgument(context, type, name, isNullable) ?? name;
+    return (
+        collectionArgument({
+            context,
+            ref,
+            type,
+            name,
+            isNullable,
+            isValueMarshalled: isValueRead(parameter),
+        }) ?? name
+    );
+};
+
+const marshalledArgument = (options: MarshalledArgumentOptions): string | undefined => {
+    const { context, ref, name, isNullable, isValueMarshalled } = options;
+
+    if (isValueMarshalled && isValueType(context, ref)) {
+        return valueArgument(context, name, isNullable);
+    }
+
+    return isHandlePassing(context, ref) ? handleArgument(context, name, isNullable) : undefined;
 };
 
 export {
@@ -681,6 +833,7 @@ export {
     renderPromisifiedBody,
     finishCallExpression,
     renderPromisifiedSignature,
+    shouldTrimFinishBoolean,
     renderMethodBody,
     renderReturnDescriptor,
     planCallArgs,

package/src/store/gi/param-marshal.ts

@@ -1,8 +1,8 @@
 import { sanitizeTypeIdentifier } from "@gtkx/utils";
-import type { TypeId } from "../../gir/type-id.js";
+import type { CArrayType, TypeId } from "../../gir/type-id.js";
 import type { GirType } from "../../gir/type.js";
 import type { ModuleContext } from "../../writer/context.js";
-import { type GirParameter, isInoutParameter } from "../../gir/parameter.js";
+import { type GirParameter, isCallerAllocatedOut, isInoutParameter } from "../../gir/parameter.js";
 import { recordInlineSize } from "./record-layout.js";
 import { isConstructibleRecord } from "./value-marshalable.js";
 
@@ -104,6 +104,62 @@ const renderCallerOutInstance = (context: ModuleContext, parameter: GirParameter
 const isCollectibleCallerOut = (context: ModuleContext, parameter: GirParameter): boolean =>
     callerOutAllocation(context, parameter) !== undefined;
 
+const hasInlineElementStride = (context: ModuleContext, array: CArrayType): boolean => {
+    if (array.elementCType?.includes("*") === true) {
+        return false;
+    }
+
+    const element = underlyingType(context, array.element);
+
+    if (element === undefined) {
+        return false;
+    }
+
+    switch (element.kind) {
+        case "primitive": {
+            return (
+                element.category !== "void" &&
+                element.category !== "string" &&
+                element.category !== "pointer" &&
+                element.category !== "unichar" &&
+                element.category !== "gtype"
+            );
+        }
+        case "enum": {
+            return true;
+        }
+        case "record": {
+            return recordInlineSize(context, element.value) !== undefined;
+        }
+        case "alias":
+        case "callback":
+        case "carray":
+        case "class":
+        case "hashtable":
+        case "interface":
+        case "list":
+        case "varargs": {
+            return false;
+        }
+    }
+};
+
+const isFixedArrayCallerOut = (context: ModuleContext, parameter: GirParameter): boolean => {
+    if (!isCallerAllocatedOut(parameter)) {
+        return false;
+    }
+
+    const type = parameter.type === undefined ? undefined : underlyingType(context, parameter.type);
+
+    return (
+        type?.kind === "carray" &&
+        type.fixedSize !== undefined &&
+        type.fixedSize > 0 &&
+        type.lengthParameterIndex === undefined &&
+        hasInlineElementStride(context, type)
+    );
+};
+
 const isAllocatableCallerOut = (context: ModuleContext, parameter: GirParameter): boolean =>
     underlyingParamKind(context, parameter) === "record" && isCollectibleCallerOut(context, parameter);
 
@@ -138,17 +194,24 @@ const isHandlePassing = (context: ModuleContext, ref: TypeId): boolean => {
     }
 };
 
-const isClosureType = (context: ModuleContext, ref: TypeId): boolean => {
+const isGObjectTypeNamed = (context: ModuleContext, ref: TypeId, typeName: string): boolean => {
     const name = context.library.nameFor(ref);
 
-    return name?.namespaceName === "GObject" && name.typeName === "Closure";
+    return name?.namespaceName === "GObject" && name.typeName === typeName;
 };
 
+const isClosureType = (context: ModuleContext, ref: TypeId): boolean => isGObjectTypeNamed(context, ref, "Closure");
+const isValueType = (context: ModuleContext, ref: TypeId): boolean => isGObjectTypeNamed(context, ref, "Value");
+const isValueTypeName = (name: TypeName): boolean => name.namespaceName === "GObject" && name.typeName === "Value";
+
 export {
     isAllocatableCallerOut,
     isClosureType,
+    isValueType,
+    isValueTypeName,
     isHandlePassedInPlace,
     isCollectibleCallerOut,
+    isFixedArrayCallerOut,
     isRecordInout,
     isHandlePassing,
     renderCallerOutInstance,

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

@@ -6,12 +6,17 @@ import type { TypeId } from "../../gir/type-id.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { renderDescriptor } from "../../analysis/descriptor-render.js";
 import { inputParameters, parameterIdentifier } from "../../analysis/param-structure.js";
-import { renderTsType } from "../../analysis/ts-type.js";
 import { renderBlock, renderBracedOrEmpty } from "../../writer/emit.js";
 import { type Callables, staticMembers } from "./callables.js";
 import { getDoc } from "./doc-spec.js";
 import { renderSourceGtype } from "./gtype-binding.js";
-import { emitFieldWrite, isEmittableField, isInlineField, isStorableFieldType } from "./record-field-accessor.js";
+import {
+    emitFieldWrite,
+    fieldTsType,
+    isEmittableField,
+    isInlineField,
+    isStorableFieldType,
+} from "./record-field-accessor.js";
 import { computeRecordFieldSlots, type RecordFieldSlot } from "./record-layout.js";
 import { isConstructibleRecord } from "./value-marshalable.js";
 
@@ -42,7 +47,7 @@ const renderRecordConstructorPropsInterface = (
         .map(
             (entry) =>
                 `${getDoc(entry.field)}${toCamelIdentifier(entry.field.name)}?: ` +
-                `${renderTsType(context, entry.field.type, true)};`,
+                `${fieldTsType(context, entry.field.type, true)};`,
         );
 
     return renderBracedOrEmpty(head, lines.join("\n"));