@gtkx/codegen 1.0.0-rc.4 → 1.1.0

package/src/analysis/inheritance.ts

@@ -1,13 +1,17 @@
-import { camelCase, lowerFirst, pascalCase, toCamelIdentifier } from "@gtkx/utils";
+import { lowerFirst, pascalCase, sanitizeTypeIdentifier, toCamelIdentifier } from "@gtkx/utils";
 import type { GirClass } from "../gir/class.js";
 import type { GirFunction } from "../gir/function.js";
 import type { Library } from "../gir/library.js";
+import type { GirParameter } from "../gir/parameter.js";
 import type { GirProperty } from "../gir/property.js";
 import type { TypeId } from "../gir/type-id.js";
 import type { ModuleContext } from "../writer/context.js";
-import { ancestorChain, type ResolvedAncestor, resolveInterface } from "../gir/ancestry.js";
-import { methodExportName } from "../store/gi/method.js";
-import { resolveAccessorType } from "../store/gi/property-accessor.js";
+import { ancestorChain, type ResolvedAncestor, resolveInterfaces } from "../gir/ancestry.js";
+import { isEmittableEntity } from "../gir/emittable.js";
+import { memberName, methodExportName } from "../store/gi/method.js";
+import { type InheritedAccessorTypes, resolveAccessorTypes } from "../store/gi/property-accessor.js";
+import { vfuncMemberNames } from "../store/gi/vtable.js";
+import { comparisonContextFor } from "../writer/comparison-context.js";
 import { inputParameters } from "./param-structure.js";
 import { renderTsType } from "./ts-type.js";
 
@@ -17,6 +21,8 @@ type AncestryContext = {
 };
 
 type OwnedProperty = { owner: GirClass; property: GirProperty };
+type DeclaredAccessorType = { type: string; owner: string };
+type DeclaredAccessorTypes = { read: DeclaredAccessorType | undefined; write: DeclaredAccessorType | undefined };
 type MethodSignature = { returnType: string; arity: number };
 
 type InheritedMethod = {
@@ -29,6 +35,11 @@ type InheritedMethods = {
     definitions: Map<string, InheritedMethod>;
 };
 
+type ParameterPair = {
+    own: GirParameter;
+    inherited: GirParameter;
+};
+
 type InheritedMatch = {
     inheritedReturn: string;
     inheritedMethod: InheritedMethod;
@@ -45,29 +56,11 @@ const RESERVED_SIGNAL_MEMBERS = new Set([
     "removeEventListener",
 ]);
 
-const resolveImplementedInterface = (
-    context: AncestryContext,
-    name: string,
-    defaultNamespace: string = context.namespace.name,
-): ResolvedAncestor | undefined => resolveInterface(context.library, defaultNamespace, name);
-
 const resolveDirectInterfaces = (
     context: AncestryContext,
     klass: GirClass,
     defaultNamespace: string,
-): ResolvedAncestor[] => {
-    const interfaces: ResolvedAncestor[] = [];
-
-    for (const implementName of klass.implements) {
-        const iface = resolveImplementedInterface(context, implementName, defaultNamespace);
-
-        if (iface !== undefined) {
-            interfaces.push(iface);
-        }
-    }
-
-    return interfaces;
-};
+): ResolvedAncestor[] => resolveInterfaces(context.library, defaultNamespace, klass.implements);
 
 const resolvePrerequisiteReference = (context: ModuleContext, name: string): string | undefined => {
     const resolved = context.library.resolveType(context.namespace.name, name);
@@ -80,7 +73,11 @@ const resolvePrerequisiteReference = (context: ModuleContext, name: string): str
         return undefined;
     }
 
-    return context.qualify(resolved.namespace.name, pascalCase(resolved.value.name));
+    if (!isEmittableEntity(resolved.value)) {
+        return undefined;
+    }
+
+    return context.qualify(resolved.namespace.name, sanitizeTypeIdentifier(resolved.value.name));
 };
 
 const forEachAncestor = (
@@ -116,7 +113,7 @@ const visitInterfaceProperties = (
     }
 };
 
-const forEachInheritedProperty = (
+const forEachAncestorProperty = (
     context: ModuleContext,
     klass: GirClass,
     visit: (owner: GirClass, property: GirProperty) => void,
@@ -130,6 +127,15 @@ const forEachInheritedProperty = (
     });
 };
 
+const forEachInheritedProperty = (
+    context: ModuleContext,
+    klass: GirClass,
+    visit: (owner: GirClass, property: GirProperty) => void,
+): void => {
+    visitInterfaceProperties(resolveDirectInterfaces(context, klass, context.namespace.name), visit);
+    forEachAncestorProperty(context, klass, visit);
+};
+
 const collectSeenPropertyNames = (context: ModuleContext, klass: GirClass): Set<string> => {
     const seen: Set<string> = new Set();
 
@@ -137,7 +143,7 @@ const collectSeenPropertyNames = (context: ModuleContext, klass: GirClass): Set<
         seen.add(toCamelIdentifier(property.name));
     }
 
-    forEachInheritedProperty(context, klass, (_owner, property) => seen.add(toCamelIdentifier(property.name)));
+    forEachAncestorProperty(context, klass, (_owner, property) => seen.add(toCamelIdentifier(property.name)));
 
     return seen;
 };
@@ -176,7 +182,7 @@ const recordAncestorSignatures = (
     signatures: Map<string, MethodSignature>,
 ): void => {
     for (const method of klass.methods) {
-        const name = camelCase(method.name);
+        const name = memberName(method.name);
 
         if (!method.introspectable || signatures.has(name)) {
             continue;
@@ -199,6 +205,9 @@ const ancestorClassMethodSignatures = (context: ModuleContext, klass: GirClass):
     return signatures;
 };
 
+const ancestorClassMethodNames = (context: ModuleContext, klass: GirClass): Set<string> =>
+    new Set(ancestorClassMethodSignatures(context, klass).keys());
+
 const mergeOmissionName = (
     context: ModuleContext,
     method: GirFunction,
@@ -208,7 +217,7 @@ const mergeOmissionName = (
         return undefined;
     }
 
-    const name = camelCase(method.name);
+    const name = memberName(method.name);
     const ancestor = ancestors.get(name);
 
     if (ancestor === undefined) {
@@ -221,43 +230,105 @@ const mergeOmissionName = (
     return ancestor.returnType !== returnType || ancestor.arity !== arity ? name : undefined;
 };
 
-const collectInterfaceMergeOmissions = (
+const classChainVfuncNames = (context: ModuleContext, klass: GirClass): Set<string> => {
+    const names: Set<string> = new Set(vfuncMemberNames(context, context.namespace.name, klass));
+
+    forEachAncestor(context, klass, (ancestor) => {
+        for (const name of vfuncMemberNames(context, ancestor.namespaceName, ancestor.klass)) {
+            names.add(name);
+        }
+    });
+
+    return names;
+};
+
+const methodMergeOmissions = (context: ModuleContext, klass: GirClass, iface: GirClass): string[] => {
+    const ancestors = ancestorClassMethodSignatures(context, klass);
+
+    return iface.methods
+        .map((method) => mergeOmissionName(context, method, ancestors))
+        .filter((name): name is string => name !== undefined);
+};
+
+const vfuncMergeOmissions = (
     context: ModuleContext,
     klass: GirClass,
     iface: { klass: GirClass; namespaceName: string },
 ): string[] => {
-    const ancestors = ancestorClassMethodSignatures(context, klass);
-    const omissions: string[] = [];
+    const claimed = classChainVfuncNames(context, klass);
 
-    for (const method of iface.klass.methods) {
-        const name = mergeOmissionName(context, method, ancestors);
+    return vfuncMemberNames(context, iface.namespaceName, iface.klass).filter((name) => claimed.has(name));
+};
 
-        if (name !== undefined) {
-            omissions.push(name);
-        }
+const collectInterfaceMergeOmissions = (
+    context: ModuleContext,
+    klass: GirClass,
+    iface: { klass: GirClass; namespaceName: string },
+): string[] => [
+    ...methodMergeOmissions(context, klass, iface.klass),
+    ...vfuncMergeOmissions(context, klass, iface),
+];
+
+const declaredBy = (type: string | undefined, owner: string): DeclaredAccessorType | undefined =>
+    type === undefined ? undefined : { type, owner };
+
+const reconcileAccessorType = (
+    jsName: string,
+    direction: string,
+    declared: DeclaredAccessorType | undefined,
+    candidate: DeclaredAccessorType | undefined,
+): DeclaredAccessorType | undefined => {
+    if (candidate === undefined) {
+        return declared;
     }
 
-    return omissions;
+    if (declared === undefined || declared.type === candidate.type) {
+        return declared ?? candidate;
+    }
+
+    throw new Error(
+        `Cannot type the ${direction} accessor of ${jsName}: ${declared.owner} declares it as ${declared.type} ` +
+        `and ${candidate.owner} declares it as ${candidate.type}. Both are bases of the same class, so no single ` +
+        "member satisfies them; correct the GIR the disagreeing base comes from.",
+    );
 };
 
-const collectInheritedPropertyTypes = (context: ModuleContext, klass: GirClass): Map<string, string> => {
-    const types: Map<string, string> = new Map();
+const recordInheritedPropertyType = (
+    context: ModuleContext,
+    types: Map<string, DeclaredAccessorTypes>,
+    owner: GirClass,
+    property: GirProperty,
+): void => {
+    const accessorTypes = resolveAccessorTypes(context, property, owner.methods);
 
-    const record = (owner: GirClass, property: GirProperty): void => {
-        const jsName = toCamelIdentifier(property.name);
+    if (accessorTypes === undefined) {
+        return;
+    }
 
-        if (types.has(jsName)) {
-            return;
-        }
+    const jsName = toCamelIdentifier(property.name);
+    const declared = types.get(jsName);
 
-        const tsType = resolveAccessorType(context, property, owner.methods);
+    types.set(jsName, {
+        read: reconcileAccessorType(jsName, "read", declared?.read, declaredBy(accessorTypes.readType, owner.name)),
+        write: reconcileAccessorType(jsName, "write", declared?.write, declaredBy(accessorTypes.writeType, owner.name)),
+    });
+};
 
-        if (tsType !== undefined) {
-            types.set(jsName, tsType);
-        }
-    };
+const collectInheritedPropertyTypes = (
+    context: ModuleContext,
+    klass: GirClass,
+): Map<string, InheritedAccessorTypes> => {
+    const declared: Map<string, DeclaredAccessorTypes> = new Map();
+
+    forEachInheritedProperty(context, klass, (owner, property) => {
+        recordInheritedPropertyType(context, declared, owner, property);
+    });
+
+    const types: Map<string, InheritedAccessorTypes> = new Map();
 
-    forEachInheritedProperty(context, klass, record);
+    for (const [jsName, entry] of declared) {
+        types.set(jsName, { readType: entry.read?.type, writeType: entry.write?.type });
+    }
 
     return types;
 };
@@ -295,7 +366,7 @@ const absorbInheritedMethods = (
             continue;
         }
 
-        const name = camelCase(method.name);
+        const name = memberName(method.name);
 
         if (returnTypes.has(name)) {
             continue;
@@ -329,11 +400,49 @@ const hasMethodConflict = (options: {
     return (
         inheritedReturn !== ownReturn ||
         hasParameterEnumConflict(context, callable, inheritedMethod) ||
-        inputParameters(context.library, callable).length !==
-        inputParameters(context.library, inheritedMethod.method).length
+        hasParameterTypeConflict(context, callable, inheritedMethod.method)
     );
 };
 
+const isCallbackType = (context: ModuleContext, ref: TypeId | undefined): boolean =>
+    ref !== undefined && context.library.typeFor(ref)?.kind === "callback";
+
+const areParametersComparable = (context: ModuleContext, pair: ParameterPair): boolean => {
+    if (isCallbackType(context, pair.own.type) && isCallbackType(context, pair.inherited.type)) {
+        return true;
+    }
+
+    const scratch = comparisonContextFor(context);
+
+    return renderTsType(scratch, pair.own.type, false) === renderTsType(scratch, pair.inherited.type, false);
+};
+
+const inputParameterPairs = (context: ModuleContext, own: GirFunction, inherited: GirFunction): ParameterPair[] => {
+    const ownParams = inputParameters(context.library, own);
+    const inheritedParams = inputParameters(context.library, inherited);
+    const pairs: ParameterPair[] = [];
+
+    for (const [index, entry] of ownParams.entries()) {
+        const other = inheritedParams[index];
+
+        if (other !== undefined) {
+            pairs.push({ own: entry.parameter, inherited: other.parameter });
+        }
+    }
+
+    return pairs;
+};
+
+const hasParameterTypeConflict = (context: ModuleContext, own: GirFunction, inherited: GirFunction): boolean => {
+    const ownCount = inputParameters(context.library, own).length;
+
+    if (ownCount !== inputParameters(context.library, inherited).length) {
+        return true;
+    }
+
+    return inputParameterPairs(context, own, inherited).some((pair) => !areParametersComparable(context, pair));
+};
+
 const conflictRename = (
     context: ModuleContext,
     callable: GirFunction,
@@ -380,26 +489,9 @@ const hasEnumConflict = (
     return ownEnum !== undefined && inheritedEnum !== undefined && ownEnum !== inheritedEnum;
 };
 
-const hasParameterEnumConflict = (context: ModuleContext, own: GirFunction, inherited: InheritedMethod): boolean => {
-    const ownParams = inputParameters(context.library, own);
-    const inheritedParams = inputParameters(context.library, inherited.method);
-    const count = Math.min(ownParams.length, inheritedParams.length);
-
-    for (let index = 0; index < count; index += 1) {
-        const ownParam = ownParams[index];
-        const inheritedParam = inheritedParams[index];
-
-        if (
-            ownParam !== undefined &&
-            inheritedParam !== undefined &&
-            hasEnumConflict(context, ownParam.parameter.type, inheritedParam.parameter.type)
-        ) {
-            return true;
-        }
-    }
-
-    return false;
-};
+const hasParameterEnumConflict = (context: ModuleContext, own: GirFunction, inherited: InheritedMethod): boolean =>
+    inputParameterPairs(context, own, inherited.method).some(
+        (pair) => hasEnumConflict(context, pair.own.type, pair.inherited.type));
 
 const enumIdentity = (context: ModuleContext, ref: TypeId | undefined): string | undefined => {
     if (ref === undefined) {
@@ -416,7 +508,7 @@ const enumIdentity = (context: ModuleContext, ref: TypeId | undefined): string |
 };
 
 export {
-    resolveImplementedInterface,
+    ancestorClassMethodNames,
     resolvePrerequisiteReference,
     forEachAncestor,
     collectInterfaceProperties,
@@ -425,6 +517,5 @@ export {
     collectInheritedMethods,
     conflictRename,
     reservedSignalMemberRename,
-    type OwnedProperty,
     type InheritedMethods,
 };

package/src/analysis/interface-conflicts.ts

@@ -0,0 +1,237 @@
+import type { GirClass } from "../gir/class.js";
+import type { GirFunction } from "../gir/function.js";
+import type { Library } from "../gir/library.js";
+import type { ModuleContext } from "../writer/context.js";
+import { resolveClassOrInterface, type ResolvedAncestor, resolveInterfaces } from "../gir/ancestry.js";
+import { isOutParameter } from "../gir/parameter.js";
+import { memberName } from "../store/gi/method.js";
+import { protectedChainSlotKeys, vfuncCallables, vfuncMemberNames } from "../store/gi/vtable.js";
+import { forEachAncestor } from "./inheritance.js";
+import { inputParameters } from "./param-structure.js";
+import { typeKey } from "./type-key.js";
+
+type MemberTable = Map<string, GirFunction>;
+
+type ClaimedMembers = {
+    inherited: MemberTable;
+    interfaces: MemberTable;
+};
+
+type InterfaceConflictOptions = {
+    context: ModuleContext;
+    klass: GirClass;
+    iface: GirClass;
+    ifaceNamespace: string;
+};
+
+type CallableKeys = {
+    inputs: string[];
+    outputs: string[];
+};
+
+type CallableKeyPair = {
+    own: CallableKeys;
+    other: CallableKeys;
+};
+
+const CHAINABLE_SIGNAL_MEMBERS = ["addEventListener", "off", "on", "once", "removeEventListener"];
+
+const callableKeys = (library: Library, fn: GirFunction): CallableKeys => ({
+    inputs: inputParameters(library, fn).map((entry) => typeKey(library, entry.parameter.type)),
+    outputs: [
+        typeKey(library, fn.returnValue.type),
+        ...fn.parameters
+            .filter((parameter) => isOutParameter(parameter))
+            .map((parameter) => typeKey(library, parameter.type)),
+    ],
+});
+
+const areKeysEqual = (left: string[], right: string[]): boolean =>
+    left.length === right.length && left.every((key, index) => key === right[index]);
+
+const callableKeyPair = (library: Library, own: GirFunction, other: GirFunction): CallableKeyPair => ({
+    own: callableKeys(library, own),
+    other: callableKeys(library, other),
+});
+
+const areCallablesIdentical = (library: Library, own: GirFunction, other: GirFunction): boolean => {
+    const keys = callableKeyPair(library, own, other);
+
+    return areKeysEqual(keys.own.inputs, keys.other.inputs) && areKeysEqual(keys.own.outputs, keys.other.outputs);
+};
+
+const areCallablesAssignable = (library: Library, own: GirFunction, other: GirFunction): boolean => {
+    const keys = callableKeyPair(library, own, other);
+
+    if (keys.own.inputs.length > keys.other.inputs.length) {
+        return false;
+    }
+
+    if (keys.own.inputs.some((key, index) => key !== keys.other.inputs[index])) {
+        return false;
+    }
+
+    return areKeysEqual(keys.other.outputs, ["void"]) || areKeysEqual(keys.own.outputs, keys.other.outputs);
+};
+
+const collectMethods = (klass: GirClass, members: MemberTable): void => {
+    for (const method of klass.methods) {
+        const name = memberName(method.name);
+
+        if (method.introspectable && !members.has(name)) {
+            members.set(name, method);
+        }
+    }
+};
+
+const inheritedMembers = (context: ModuleContext, klass: GirClass): ClaimedMembers => {
+    const inherited: MemberTable = new Map();
+
+    forEachAncestor(context, klass, (ancestor) => {
+        collectMethods(ancestor.klass, inherited);
+    });
+
+    return { inherited, interfaces: new Map() };
+};
+
+const interfaceMembers = (options: InterfaceConflictOptions): MemberTable => {
+    const members: MemberTable = new Map();
+    collectMethods(options.iface, members);
+
+    for (const [key, callable] of vfuncCallables(options.context, options.ifaceNamespace, options.iface)) {
+        members.set(key, callable);
+    }
+
+    return members;
+};
+
+const claimInterfaceMembers = (options: InterfaceConflictOptions, claimed: ClaimedMembers): void => {
+    for (const [key, callable] of interfaceMembers(options)) {
+        if (!claimed.interfaces.has(key)) {
+            claimed.interfaces.set(key, callable);
+        }
+    }
+};
+
+const isConflictingMember = (library: Library, claimed: ClaimedMembers, entry: [string, GirFunction]): boolean => {
+    const [name, method] = entry;
+    const owned = claimed.inherited.get(name);
+
+    if (owned !== undefined) {
+        return !areCallablesAssignable(library, owned, method);
+    }
+
+    const sibling = claimed.interfaces.get(name);
+
+    return sibling !== undefined && !areCallablesIdentical(library, sibling, method);
+};
+
+const conflictingMemberNames = (options: InterfaceConflictOptions, claimed: ClaimedMembers): string[] =>
+    [...interfaceMembers(options)]
+        .filter((entry) => isConflictingMember(options.context.library, claimed, entry))
+        .map(([name]) => name);
+
+const protectedVfuncNames = (options: InterfaceConflictOptions): string[] => {
+    const { context, klass, iface, ifaceNamespace } = options;
+    const protectedKeys = protectedChainSlotKeys(context, klass);
+
+    return vfuncMemberNames(context, ifaceNamespace, iface).filter((key) => protectedKeys.has(key));
+};
+
+const interfaceConflicts = (options: InterfaceConflictOptions, claimed: ClaimedMembers): string[] => {
+    const names = [...conflictingMemberNames(options, claimed), ...protectedVfuncNames(options)];
+
+    return names.length === 0 ? names : [...new Set([...names, ...CHAINABLE_SIGNAL_MEMBERS])];
+};
+
+const rootPrerequisite = (library: Library): ResolvedAncestor[] => {
+    const root = resolveClassOrInterface(library, "GObject", "Object");
+
+    return root === undefined ? [] : [root];
+};
+
+const interfaceSupertypes = (library: Library, entry: ResolvedAncestor): ResolvedAncestor[] => {
+    const prerequisites = entry.klass.prerequisites
+        .map((name) => resolveClassOrInterface(library, entry.namespaceName, name))
+        .filter((prerequisite) => prerequisite !== undefined);
+
+    return prerequisites.length === 0 ? rootPrerequisite(library) : prerequisites;
+};
+
+const classSupertypes = (library: Library, entry: ResolvedAncestor): ResolvedAncestor[] => {
+    const interfaces = resolveInterfaces(library, entry.namespaceName, entry.klass.implements);
+
+    if (entry.klass.parent === undefined) {
+        return interfaces;
+    }
+
+    const parent = resolveClassOrInterface(library, entry.namespaceName, entry.klass.parent);
+
+    return parent === undefined ? interfaces : [parent, ...interfaces];
+};
+
+const directSupertypes = (library: Library, entry: ResolvedAncestor): ResolvedAncestor[] =>
+    entry.klass.isInterface ? interfaceSupertypes(library, entry) : classSupertypes(library, entry);
+
+const collectSupertypeMembers = (
+    library: Library,
+    entry: ResolvedAncestor,
+    visited: Set<string>,
+    members: MemberTable,
+): void => {
+    const key = `${entry.namespaceName}.${entry.klass.name}`;
+
+    if (visited.has(key)) {
+        return;
+    }
+
+    visited.add(key);
+    collectMethods(entry.klass, members);
+
+    for (const supertype of directSupertypes(library, entry)) {
+        collectSupertypeMembers(library, supertype, visited, members);
+    }
+};
+
+const supertypeMembers = (library: Library, base: ResolvedAncestor): MemberTable => {
+    const members: MemberTable = new Map();
+    collectSupertypeMembers(library, base, new Set(), members);
+
+    return members;
+};
+
+const prerequisiteConflicts = (library: Library, iface: GirClass, base: ResolvedAncestor): string[] => {
+    const members: MemberTable = new Map();
+    collectMethods(iface, members);
+    const inherited = supertypeMembers(library, base);
+    const names: string[] = [];
+
+    for (const [name, method] of members) {
+        const owned = inherited.get(name);
+
+        if (owned !== undefined && !areCallablesAssignable(library, method, owned)) {
+            names.push(name);
+        }
+    }
+
+    return names;
+};
+
+const omittedTypeRef = (typeRef: string, omissions: string[]): string => {
+    if (omissions.length === 0) {
+        return typeRef;
+    }
+
+    const keys = [...new Set(omissions)].map((name) => JSON.stringify(name)).join(" | ");
+
+    return `Omit<${typeRef}, ${keys}>`;
+};
+
+export {
+    type ClaimedMembers,
+    claimInterfaceMembers,
+    inheritedMembers,
+    interfaceConflicts,
+    omittedTypeRef,
+    prerequisiteConflicts,
+};

package/src/analysis/nul-terminated-bytes.ts

@@ -0,0 +1,31 @@
+import type { Library } from "../gir/library.js";
+import type { GirCallable, GirParameter } from "../gir/parameter.js";
+import type { TypeId } from "../gir/type-id.js";
+import { isOutParameter } from "../gir/parameter.js";
+import { carrayFor, isUnboundedArray, primitiveCategoryFor } from "./type-shape.js";
+
+const BYTE_CATEGORIES: Set<string> = new Set(["int8", "uint8"]);
+const CHAR_POINTER = /char\s*\*/;
+
+const isByteElement = (library: Library, element: TypeId): boolean => {
+    const category = primitiveCategoryFor(library, element);
+
+    return category !== undefined && BYTE_CATEGORIES.has(category);
+};
+
+const isNulTerminatedBytes = (library: Library, ref: TypeId | undefined): boolean => {
+    const type = carrayFor(library, ref);
+
+    if (type?.arrayCType === undefined || !CHAR_POINTER.test(type.arrayCType)) {
+        return false;
+    }
+
+    return isUnboundedArray(type) && isByteElement(library, type.element);
+};
+
+const nulTerminatedByteParams = (library: Library, callable: GirCallable): GirParameter[] =>
+    callable.parameters.filter(
+        (parameter) => !isOutParameter(parameter) && isNulTerminatedBytes(library, parameter.type),
+    );
+
+export { nulTerminatedByteParams };