@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.3

package/src/analysis/param-structure.ts

@@ -1,127 +1,258 @@
 import { toCamelIdentifier } from "@gtkx/utils";
 import type { GirFunction } from "../gir/function.js";
 import type { Library } from "../gir/library.js";
-import { type GirParameter, type GirSignal, isCallerAllocatedOut, isOutParameter } from "../gir/parameter.js";
 import type { TypeId } from "../gir/type-id.js";
-import { isCellInout, omitsPrimaryReturn } from "./descriptor-render.js";
+import { type GirCallable, type GirParameter, isCallerAllocatedOut, isOutParameter } from "../gir/parameter.js";
+import { isCellInout, shouldOmitPrimaryReturn } from "./descriptor-render.js";
 
 type InputParameter = {
     parameter: GirParameter;
     index: number;
 };
 
-export const inputParameters = (library: Library, fn: GirFunction): InputParameter[] => {
+type HandlerResultOptions = {
+    library: Library;
+    signal: GirCallable;
+    renderType: (ref: TypeId | undefined, isNullable: boolean) => string;
+    includeCallerAllocated: boolean;
+    optOut: boolean;
+};
+
+const isInputParameter = (options: {
+    parameter: GirParameter;
+    index: number;
+    lengthIndices: Set<number>;
+    closureIndices: Set<number>;
+}): boolean => {
+    const { parameter, index, lengthIndices, closureIndices } = options;
+
+    if (parameter.isVarargs) {
+        return false;
+    }
+
+    if (isOutParameter(parameter)) {
+        return false;
+    }
+
+    if (isCallerAllocatedOut(parameter)) {
+        return false;
+    }
+
+    if (lengthIndices.has(index)) {
+        return false;
+    }
+
+    return !closureIndices.has(index);
+};
+
+const inputParameters = (library: Library, fn: GirFunction): InputParameter[] => {
     const lengthIndices = arrayLengthIndices(library, fn);
     const closureIndices = closureAndDestroyIndices(fn);
     const result: InputParameter[] = [];
-    fn.parameters.forEach((parameter, index) => {
-        if (parameter.isVarargs) return;
-        if (isOutParameter(parameter)) return;
-        if (isCallerAllocatedOut(parameter)) return;
-        if (lengthIndices.has(index)) return;
-        if (closureIndices.has(index)) return;
-        result.push({ parameter, index });
-    });
+
+    for (const [index, parameter] of fn.parameters.entries()) {
+        if (isInputParameter({ parameter, index, lengthIndices, closureIndices })) {
+            result.push({ parameter, index });
+        }
+    }
+
     return result;
 };
 
-export const closureAndDestroyIndices = (fn: GirFunction): Set<number> => {
-    const indices = new Set<number>();
+const closureAndDestroyIndices = (fn: GirFunction): Set<number> => {
+    const indices: Set<number> = new Set();
+
     for (const parameter of fn.parameters) {
-        if (parameter.closureIndex !== undefined) indices.add(parameter.closureIndex);
-        if (parameter.destroyIndex !== undefined) indices.add(parameter.destroyIndex);
+        if (parameter.closureIndex !== undefined) {
+            indices.add(parameter.closureIndex);
+        }
+
+        if (parameter.destroyIndex !== undefined) {
+            indices.add(parameter.destroyIndex);
+        }
     }
+
     return indices;
 };
 
+// The emitted argument list is the instance parameter followed by every parameter `planParameter`
+// keeps, so a GIR index only lines up with an emitted index when nothing before it was dropped.
+const emittedArgIndices = (fn: GirFunction, instanceOffset: number): Map<number, number> => {
+    const closureIndices = closureAndDestroyIndices(fn);
+    const map: Map<number, number> = new Map();
+    let emitted = instanceOffset;
+
+    for (const [index, parameter] of fn.parameters.entries()) {
+        if (parameter.isVarargs || closureIndices.has(index)) {
+            continue;
+        }
+
+        map.set(index, emitted);
+        emitted += 1;
+    }
+
+    return map;
+};
+
 const arrayLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
     const map = arrayLengthSources(library, fn);
+
     return new Set(map.keys());
 };
 
-export const arrayLengthSources = (library: Library, fn: GirFunction): Map<number, number> => {
-    const map = new Map<number, number>();
-    fn.parameters.forEach((parameter, index) => {
-        const type = parameter.type === undefined ? undefined : library.typeOf(parameter.type);
-        if (type?.kind !== "carray") return;
-        const lengthIndex = type.lengthParameterIndex;
-        if (lengthIndex === undefined) return;
-        map.set(lengthIndex, index);
-    });
+const carrayLengthIndex = (library: Library, ref: TypeId | undefined): number | undefined => {
+    const type = ref === undefined ? undefined : library.typeFor(ref);
+
+    if (type?.kind !== "carray") {
+        return undefined;
+    }
+
+    return type.lengthParameterIndex;
+};
+
+const arrayLengthSources = (library: Library, fn: GirFunction): Map<number, number> => {
+    const map: Map<number, number> = new Map();
+
+    for (const [index, parameter] of fn.parameters.entries()) {
+        const lengthIndex = carrayLengthIndex(library, parameter.type);
+
+        if (lengthIndex !== undefined) {
+            map.set(lengthIndex, index);
+        }
+    }
+
     return map;
 };
 
-export const hasCallerAllocatedArrayLength = (library: Library, fn: GirFunction): boolean => {
+const hasCallerAllocatedArrayLength = (library: Library, fn: GirFunction): boolean => {
     for (const arrayIndex of arrayLengthSources(library, fn).values()) {
         const array = fn.parameters[arrayIndex];
-        if (array !== undefined && isCallerAllocatedOut(array)) return true;
+
+        if (array !== undefined && isCallerAllocatedOut(array)) {
+            return true;
+        }
     }
+
     return false;
 };
 
 const returnArrayLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
-    const returnType = fn.returnValue.type === undefined ? undefined : library.typeOf(fn.returnValue.type);
-    if (returnType?.kind !== "carray") return new Set();
+    const returnType = fn.returnValue.type === undefined ? undefined : library.typeFor(fn.returnValue.type);
+
+    if (returnType?.kind !== "carray") {
+        return new Set();
+    }
+
     const lengthIndex = returnType.lengthParameterIndex;
-    if (lengthIndex === undefined) return new Set();
+
+    if (lengthIndex === undefined) {
+        return new Set();
+    }
+
     return new Set([lengthIndex]);
 };
 
-export const foldedLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
-    const indices = new Set<number>(arrayLengthSources(library, fn).keys());
-    for (const index of returnArrayLengthIndices(library, fn)) indices.add(index);
+const foldedLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
+    const indices: Set<number> = new Set(arrayLengthSources(library, fn).keys());
+
+    for (const index of returnArrayLengthIndices(library, fn)) {
+        indices.add(index);
+    }
+
     return indices;
 };
 
-export const parameterIdentifier = (parameter: GirParameter, index: number): string => {
-    if (parameter.name.length === 0) return `arg${index}`;
+const parameterIdentifier = (parameter: GirParameter, index: number): string => {
+    if (parameter.name.length === 0) {
+        return `arg${String(index)}`;
+    }
+
     return toCamelIdentifier(parameter.name);
 };
 
-export const renderHandlerParameters = (
+const renderHandlerParameters = (
     parameters: GirParameter[],
-    renderType: (ref: TypeId | undefined, nullable: boolean) => string,
-    additionalExclude: (parameter: GirParameter) => boolean = () => false,
+    renderType: (ref: TypeId | undefined, isNullable: boolean) => string,
+    shouldExclude: (parameter: GirParameter) => boolean = () => false,
 ): string[] =>
     parameters
-        .filter((parameter) => !parameter.isVarargs && !isOutParameter(parameter) && !additionalExclude(parameter))
+        .filter((parameter) => !parameter.isVarargs && !isOutParameter(parameter) && !shouldExclude(parameter))
         .map(
             (parameter, index) =>
                 `${parameterIdentifier(parameter, index)}: ${renderType(parameter.type, parameter.nullable)}`,
         );
 
-export const foldOutParamShape = (primary: string | undefined, outTypes: string[]): string => {
-    if (primary !== undefined) return `[${primary}, ${outTypes.join(", ")}]`;
+const foldOutParamShape = (primary: string | undefined, outTypes: string[]): string => {
+    if (primary !== undefined) {
+        return `[${primary}, ${outTypes.join(", ")}]`;
+    }
+
     const [single, ...rest] = outTypes;
-    if (rest.length === 0 && single !== undefined) return single;
+
+    if (single !== undefined && rest.length === 0) {
+        return single;
+    }
+
     return `[${outTypes.join(", ")}]`;
 };
 
-type HandlerResultOptions = {
+const isHandlerOutParameter = (options: {
     library: Library;
-    signal: GirSignal;
-    renderType: (ref: TypeId | undefined, nullable: boolean) => string;
+    parameter: GirParameter;
     includeCallerAllocated: boolean;
-    optOut: boolean;
+}): boolean => {
+    const { library, parameter, includeCallerAllocated } = options;
+
+    if (parameter.isVarargs) {
+        return false;
+    }
+
+    if (isOutParameter(parameter)) {
+        return true;
+    }
+
+    if (isCellInout(library, parameter)) {
+        return true;
+    }
+
+    return includeCallerAllocated && isCallerAllocatedOut(parameter);
 };
 
-export const renderHandlerResultType = (options: HandlerResultOptions): string => {
+const scalarResultType = (primary: string | undefined, isOptOut: boolean): string => {
+    if (primary === undefined) {
+        return "void";
+    }
+
+    return isOptOut ? `${primary} | undefined` : primary;
+};
+
+const renderHandlerResultType = (options: HandlerResultOptions): string => {
     const { library, signal, renderType, includeCallerAllocated, optOut } = options;
-    const primary = omitsPrimaryReturn(library, signal.returnValue)
+
+    const primary = shouldOmitPrimaryReturn(library, signal.returnValue)
         ? undefined
         : renderType(signal.returnValue.type, signal.returnValue.nullable);
+
     const outTypes = signal.parameters
-        .filter(
-            (parameter) =>
-                !parameter.isVarargs &&
-                (isOutParameter(parameter) ||
-                    isCellInout(library, parameter) ||
-                    (includeCallerAllocated && isCallerAllocatedOut(parameter))),
-        )
-        .map((parameter) => renderType(parameter.type, false));
+        .filter((parameter) => isHandlerOutParameter({ library, parameter, includeCallerAllocated }))
+        .map((parameter) => renderType(parameter.type, parameter.nullable));
+
     if (outTypes.length === 0) {
-        if (primary === undefined) return "void";
-        return optOut ? `${primary} | undefined` : primary;
+        return scalarResultType(primary, optOut);
     }
+
     return foldOutParamShape(primary, outTypes);
 };
+
+export {
+    emittedArgIndices,
+    inputParameters,
+    closureAndDestroyIndices,
+    arrayLengthSources,
+    hasCallerAllocatedArrayLength,
+    foldedLengthIndices,
+    parameterIdentifier,
+    renderHandlerParameters,
+    foldOutParamShape,
+    renderHandlerResultType,
+};

package/src/analysis/ts-type.ts

@@ -1,17 +1,22 @@
 import type { Library } from "../gir/library.js";
-import { PRIMITIVE_TS_TYPE } from "../gir/primitives.js";
 import type { EntityType, GirType } from "../gir/type.js";
-import type { TypeId } from "../gir/type-id.js";
-import { isClassStructRecord } from "../store/gi/class-struct-record.js";
-import { gtypeTsType } from "../store/gi/gtype-binding.js";
 import type { ModuleContext } from "../writer/context.js";
+import { PRIMITIVE_TS_TYPE } from "../gir/primitives.js";
+import {
+    type CArrayType,
+    type HashTableType,
+    hasUnknownArrayLength,
+    type ListType,
+    type TypeId,
+} from "../gir/type-id.js";
+import { gtypeTsType } from "../store/gi/gtype-binding.js";
 
 type ReferenceName = {
     namespaceName: string;
     typeName: string;
 };
 
-export type TsTypeTarget = {
+type TsTypeTarget = {
     containerStyle: "map" | "record";
     callbackType: string;
     byteArrayAsNumber: boolean;
@@ -19,58 +24,105 @@ export type TsTypeTarget = {
     renderGtype: () => string;
 };
 
-const willEmitEntity = (library: Library, type: EntityType): boolean => {
+const willEmitEntity = (type: EntityType): boolean => {
     switch (type.kind) {
-        case "callback":
+        case "callback": {
             return type.value.introspectable && type.value.name.length > 0;
-        case "record":
-            return (
-                type.value.introspectable &&
-                !type.value.isVtable &&
-                type.value.name.length > 0 &&
-                !isClassStructRecord(library, type.namespace.name, type.value)
-            );
-        default:
+        }
+        case "record": {
+            return type.value.introspectable && type.value.name.length > 0;
+        }
+        case "alias":
+        case "class":
+        case "enum":
+        case "interface": {
             return true;
+        }
     }
 };
 
-export const renderBaseTypeFor = (library: Library, target: TsTypeTarget, ref: TypeId | undefined): string => {
-    if (ref === undefined) return "void";
-    const type = library.typeOf(ref);
-    const name = library.nameOf(ref);
-    if (type === undefined) return renderNamedType(target, undefined, name);
+const renderPrimitiveType = (target: TsTypeTarget, type: Extract<GirType, { kind: "primitive" }>): string =>
+    type.category === "gtype" ? target.renderGtype() : PRIMITIVE_TS_TYPE[type.category];
+
+const renderEntityType = (
+    target: TsTypeTarget,
+    type: EntityType,
+    name: ReferenceName | undefined,
+): string => renderNamedType(target, type, willEmitEntity(type) ? name : undefined);
+
+const renderBaseType = (library: Library, target: TsTypeTarget, ref: TypeId | undefined): string => {
+    if (ref === undefined) {
+        return "void";
+    }
+
+    const type = library.typeFor(ref);
+    const name = library.nameFor(ref);
+
+    if (type === undefined) {
+        return renderNamedType(target, undefined, name);
+    }
+
     switch (type.kind) {
-        case "primitive":
-            return type.category === "gtype" ? target.renderGtype() : PRIMITIVE_TS_TYPE[type.category];
-        case "varargs":
+        case "primitive": {
+            return renderPrimitiveType(target, type);
+        }
+        case "varargs": {
             return "unknown[]";
+        }
         case "callback":
         case "class":
         case "interface":
         case "record":
         case "enum":
-        case "alias":
-            return renderNamedType(target, type, willEmitEntity(library, type) ? name : undefined);
+        case "alias": {
+            return renderEntityType(target, type, name);
+        }
         case "carray":
-            return `${renderBaseTypeFor(library, target, type.element)}[]`;
         case "list":
-            if (type.flavor === "gbytearray" && target.byteArrayAsNumber) return "number[]";
-            return `${renderBaseTypeFor(library, target, type.element)}[]`;
         case "hashtable": {
-            const key = renderBaseTypeFor(library, target, type.key);
-            const value = renderBaseTypeFor(library, target, type.value);
-            return target.containerStyle === "record" ? `Record<${key}, ${value}>` : `Map<${key}, ${value}>`;
+            return renderContainerType(library, target, type);
         }
     }
 };
 
+const renderContainerType = (
+    library: Library,
+    target: TsTypeTarget,
+    type: CArrayType | ListType | HashTableType,
+): string => {
+    if (type.kind === "hashtable") {
+        const key = renderBaseType(library, target, type.key);
+        const value = renderBaseType(library, target, type.value);
+
+        return target.containerStyle === "record" ? `Record<${key}, ${value}>` : `Map<${key}, ${value}>`;
+    }
+
+    return renderSequenceType(library, target, type);
+};
+
+// An array whose length nothing states decodes as the bare pointer it is, so its TypeScript type has
+// to say so too rather than promising elements nothing can count.
+const renderSequenceType = (library: Library, target: TsTypeTarget, type: CArrayType | ListType): string => {
+    if (type.kind === "list" && type.flavor === "gbytearray" && target.byteArrayAsNumber) {
+        return "number[]";
+    }
+
+    if (type.kind === "carray" && hasUnknownArrayLength(type)) {
+        return "number";
+    }
+
+    return `${renderBaseType(library, target, type.element)}[]`;
+};
+
 const renderNamedType = (
     target: TsTypeTarget,
     resolved: GirType | undefined,
     name: ReferenceName | undefined,
 ): string => {
-    if (name === undefined) return resolved?.kind === "callback" ? target.callbackType : "unknown";
+    if (name === undefined || name.typeName.length === 0) {
+        return resolved?.kind === "callback" ? target.callbackType : "unknown";
+    }
+
     return target.renderNamed(resolved, name);
 };
 
@@ -82,7 +134,34 @@ const moduleTarget = (context: ModuleContext): TsTypeTarget => ({
     renderGtype: () => gtypeTsType(context),
 });
 
-export const renderTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string => {
-    const base = renderBaseTypeFor(context.library, moduleTarget(context), ref);
+const renderTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string => {
+    const base = renderBaseType(context.library, moduleTarget(context), ref);
+
     return isNullable ? `${base} | null` : base;
 };
+
+const recordTypeTarget = (
+    library: Library,
+    renderNamedRef: (name: ReferenceName) => string,
+    renderGtype: () => string,
+): TsTypeTarget => {
+    const target: TsTypeTarget = {
+        containerStyle: "record",
+        callbackType: "((...args: unknown[]) => unknown)",
+        byteArrayAsNumber: false,
+        renderNamed: (resolved, name) => {
+            if (resolved?.kind === "alias") {
+                return resolved.value.target === undefined
+                    ? "number"
+                    : renderBaseType(library, target, resolved.value.target);
+            }
+
+            return renderNamedRef(name);
+        },
+        renderGtype,
+    };
+
+    return target;
+};
+
+export { renderBaseType, renderTsType, recordTypeTarget, type TsTypeTarget };