@gtkx/codegen 1.1.0 → 1.2.0

package/src/store/compile-store.ts

@@ -1,52 +1,19 @@
-import { rmSync, writeFileSync } from "node:fs";
+import { rmSync } from "node:fs";
 import { join } from "node:path";
-import { compileProject, type ProjectFile, type SourceModule } from "../compile.js";
+import { emitModules, type SourceModule } from "../compile.js";
 
 type CompileStoreParams = {
     storeDir: string;
     files: SourceModule[];
     packageName: string;
-    requiresEnvReference?: boolean;
-};
-
-const EMIT_OPTIONS = {
-    declaration: true,
-    removeComments: false,
-    sourceMap: false,
-    declarationMap: false,
-    rootDir: ".",
-    outDir: ".",
-};
-
-const ENV_REFERENCE_FILE = "__gtkx-env__.d.ts";
-
-const writeEnvReference = (storeDir: string): (() => void) => {
-    writeFileSync(join(storeDir, ENV_REFERENCE_FILE), "/// <reference types=\"@gtkx/react/env\" />\n");
-
-    return () => {
-        rmSync(join(storeDir, ENV_REFERENCE_FILE), { force: true });
-    };
 };
 
 const compileStore = (params: CompileStoreParams): void => {
-    const removeEnvReference = params.requiresEnvReference === true
-        ? writeEnvReference(params.storeDir)
-        : (): void => undefined;
-
-    const files: ProjectFile[] = params.requiresEnvReference === true
-        ? [{ fileName: ENV_REFERENCE_FILE }, ...params.files]
-        : params.files;
-
-    try {
-        compileProject({
-            projectDir: params.storeDir,
-            files,
-            compilerOptions: EMIT_OPTIONS,
-            label: `the generated ${params.packageName} store`,
-        });
-    } finally {
-        removeEnvReference();
-    }
+    emitModules({
+        projectDir: params.storeDir,
+        files: params.files,
+        label: `the generated ${params.packageName} store`,
+    });
 
     for (const file of params.files) {
         rmSync(join(params.storeDir, file.fileName), { force: true });

package/src/store/gi/callables.ts

@@ -69,6 +69,15 @@ type PlainTypeMembersOptions = {
     hasGtype: boolean;
 };
 
+const RUNTIME_OWNED_LIFETIME_METHODS: Set<string> = new Set([
+    "force_floating",
+    "free",
+    "ref",
+    "ref_sink",
+    "take_ref",
+    "unref",
+]);
+
 const renderInstanceMethodSignature: InstanceMemberRenderer = instanceMemberRenderer(
     (context, callable, { name, finishFn }) =>
         `${memberDoc(context, callable, finishFn)}${memberSignatureText(context, callable, name, { finishFn })};`,
@@ -373,6 +382,7 @@ const isEmittableCallable = (context: ModuleContext, callable: GirFunction): boo
     callable.introspectable &&
     callable.shadowedBy === undefined &&
     callable.cIdentifier !== undefined &&
+    !RUNTIME_OWNED_LIFETIME_METHODS.has(callable.name) &&
     !hasUnmarshalableParam(context, callable);
 
 const constructorMemberName = (girName: string): string | undefined => {
@@ -408,6 +418,20 @@ const renderStaticSignature = (
     };
 };
 
+const staticMemberName = (
+    context: ModuleContext,
+    callable: GirFunction,
+    resolveName: (girName: string) => string | undefined,
+): string | undefined => {
+    if (!isEmittableCallable(context, callable)) {
+        return undefined;
+    }
+
+    const name = resolveName(callable.name);
+
+    return name !== undefined && isEmittableMemberName(name) ? name : undefined;
+};
+
 const collectStaticMembers = (
     context: ModuleContext,
     group: GirFunction[],
@@ -416,7 +440,7 @@ const collectStaticMembers = (
     const members: StaticMember[] = [];
 
     for (const callable of group) {
-        const name = isEmittableCallable(context, callable) ? resolveName(callable.name) : undefined;
+        const name = staticMemberName(context, callable, resolveName);
 
         if (name !== undefined) {
             members.push({ callable, name });
@@ -427,13 +451,10 @@ const collectStaticMembers = (
 };
 
 const staticMembers = (context: ModuleContext, callables: Callables): StaticMember[] => [
-    ...collectStaticMembers(context, callables.constructors, constructorMemberName),
+    ...collectStaticMembers(context, callables.constructors, memberName),
     ...collectStaticMembers(context, callables.functions, memberName),
 ];
 
-const constructorMemberNames = (context: ModuleContext, constructors: GirFunction[]): string[] =>
-    collectStaticMembers(context, constructors, constructorMemberName).map((member) => member.name);
-
 const collectStaticEntries = (
     context: ModuleContext,
     group: GirFunction[],
@@ -513,10 +534,8 @@ export {
     dedupeCallables,
     generateBindings,
     matchStaticFinishFunction,
-    indexMethodsByName,
     isEmittableCallable,
     renderStaticSignature,
-    constructorMemberNames,
     renderStaticHead,
     renderPlainTypeMembers,
     staticMembers,

package/src/store/gi/class.ts

@@ -11,10 +11,12 @@ import {
     type InheritedMethods,
 } from "../../analysis/inheritance.js";
 import {
+    areCallablesAssignable,
     type ClaimedMembers,
     claimInterfaceMembers,
     inheritedMembers,
     interfaceConflicts,
+    omittedKeys,
     omittedTypeRef,
 } from "../../analysis/interface-conflicts.js";
 import { ancestorChain, getParentRef, type ResolvedAncestor } from "../../gir/ancestry.js";
@@ -22,13 +24,13 @@ import { isEmittableEntity } from "../../gir/emittable.js";
 import { indentMembers } from "../../writer/emit.js";
 import {
     type Callables,
-    constructorMemberNames,
     dedupeCallables,
     generateBindings,
     type InstanceScope,
     instanceScope,
     renderClassInstanceMember,
     renderStaticHead,
+    staticMembers,
 } from "./callables.js";
 import { renderClassConstructor, renderConstructorPropsInterface } from "./constructor-props.js";
 import { getDoc } from "./doc-spec.js";
@@ -91,7 +93,7 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
 
     generateBindings(context, callables);
     const parentExpression = resolveParent(context, klass);
-    const extendsClause = renderExtendsClause(context, parentExpression, callables);
+    const extendsClause = renderExtendsClause(context, parentExpression, klass, callables);
     const implemented = resolveImplementedRefs(context, klass);
     const typeRefs = implemented.map((ref) => omittedTypeRef(ref.typeRef, ref.conflicts));
     const implementsClause = typeRefs.length === 0 ? "" : ` implements ${typeRefs.join(", ")}`;
@@ -189,7 +191,6 @@ const renderClassMembers = (
             context,
             property,
             claimedNames,
-            methodByName: scope.methodByName,
             inheritedTypes,
             inheritedNames,
         });
@@ -336,25 +337,80 @@ const resolveImplementedRefs = (context: ModuleContext, klass: GirClass): Implem
     return refs;
 };
 
+const classCallables = (klass: GirClass): Callables => ({
+    constructors: klass.constructors,
+    functions: klass.functions,
+    methods: klass.methods,
+});
+
+const resolveParentClass = (context: ModuleContext, klass: GirClass): ResolvedAncestor | undefined => {
+    const parent = getParentRef(klass);
+
+    if (parent === undefined) {
+        return undefined;
+    }
+
+    const resolved = context.library.resolveType(parent.namespaceName ?? context.namespace.name, parent.typeName);
+
+    return resolved?.kind === "class" ? { klass: resolved.value, namespaceName: resolved.namespace.name } : undefined;
+};
+
+const addAncestorStatics = (context: ModuleContext, klass: GirClass, table: Map<string, GirFunction>): void => {
+    const members = staticMembers(context, classCallables(klass));
+
+    for (const member of members) {
+        if (!table.has(member.name)) {
+            table.set(member.name, member.callable);
+        }
+    }
+};
+
+const inheritedStatics = (context: ModuleContext, klass: GirClass): Map<string, GirFunction> => {
+    const table: Map<string, GirFunction> = new Map();
+    const parent = resolveParentClass(context, klass);
+
+    if (parent === undefined) {
+        return table;
+    }
+
+    for (const ancestor of ancestorChain(context.library, parent.klass, parent.namespaceName)) {
+        addAncestorStatics(context, ancestor.klass, table);
+    }
+
+    return table;
+};
+
+const shadowedStaticNames = (context: ModuleContext, klass: GirClass, callables: Callables): string[] => {
+    const inherited = inheritedStatics(context, klass);
+
+    return staticMembers(context, callables)
+        .filter((member) => {
+            const shadowed = inherited.get(member.name);
+
+            return shadowed !== undefined && !areCallablesAssignable(context.library, member.callable, shadowed);
+        })
+        .map((member) => member.name);
+};
+
 const renderExtendsClause = (
     context: ModuleContext,
     parentExpression: string | undefined,
+    klass: GirClass,
     callables: Callables,
 ): string => {
     if (parentExpression === undefined) {
         return "";
     }
 
-    const constructorNames = constructorMemberNames(context, callables.constructors);
+    const staticNames = shadowedStaticNames(context, klass, callables);
 
-    if (constructorNames.length === 0) {
+    if (staticNames.length === 0) {
         return ` extends ${parentExpression}`;
     }
 
     context.addRuntimeTypeImport("StaticBase");
-    const omitted = constructorNames.map((name) => JSON.stringify(name)).join(" | ");
 
-    return ` extends (${parentExpression} as StaticBase<typeof ${parentExpression}, ${omitted}>)`;
+    return ` extends (${parentExpression} as StaticBase<typeof ${parentExpression}, ${omittedKeys(staticNames)}>)`;
 };
 
 const resolveParent = (context: ModuleContext, klass: GirClass): string | undefined => {

package/src/store/gi/constant.ts

@@ -7,7 +7,7 @@ import { isEmittableEntity } from "../../gir/emittable.js";
 import { getDoc } from "./doc-spec.js";
 
 const TRUE_VALUES: Set<string> = new Set(["true", "1"]);
-const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["bigint64", "biguint64", "gtype"]);
+const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["bigint64", "biguint64", "gtype", "pointer"]);
 
 const generateConstant = (context: ModuleContext, constant: GirConstant): void => {
     if (!isEmittableEntity(constant)) {

package/src/store/gi/enum.ts

@@ -1,4 +1,4 @@
-import { sanitizeTypeIdentifier, sourceStringLiteral, uniqBy } from "@gtkx/utils";
+import { escapeIdentifierStart, sanitizeTypeIdentifier, sourceStringLiteral, uniqBy } from "@gtkx/utils";
 import type { EnumMember, GirEnum } from "../../gir/enum.js";
 import type { ModuleContext } from "../../writer/context.js";
 import { hasAnnotations } from "../../gir/annotations.js";
@@ -94,11 +94,7 @@ const appendEnumDeclaration = (context: ModuleContext, enumeration: GirEnum, mem
     });
 };
 
-const enumMemberKey = (name: string): string => {
-    const upper = name.toUpperCase().replaceAll("-", "_");
-
-    return /^\d/.test(upper) ? `_${upper}` : upper;
-};
+const enumMemberKey = (name: string): string => escapeIdentifierStart(name.toUpperCase().replaceAll("-", "_"));
 
 const renderQuarkExpression = (context: ModuleContext, errorDomain: string): string => {
     if (context.namespace.name === "GLib") {

package/src/store/gi/interface.ts

@@ -336,11 +336,11 @@ const collectMethodMembers = (options: MethodMemberOptions): string[] => {
 };
 
 const collectPropertyMembers = (options: PropertyMemberOptions): string[] => {
-    const { context, iface, scope, renderers, claimedNames } = options;
+    const { context, iface, renderers, claimedNames } = options;
     const members: string[] = [];
 
     for (const property of iface.properties) {
-        const block = renderers.renderProperty({ context, property, claimedNames, methodByName: scope.methodByName });
+        const block = renderers.renderProperty({ context, property, claimedNames });
 
         if (block !== undefined) {
             members.push(block);

package/src/store/gi/method.ts

@@ -1,4 +1,4 @@
-import { camelCase, sourceStringLiteral } from "@gtkx/utils";
+import { camelCase, escapeIdentifierStart, sourceStringLiteral } from "@gtkx/utils";
 import type { GirFunction } from "../../gir/function.js";
 import type { GirType } from "../../gir/type.js";
 import type { ModuleContext } from "../../writer/context.js";
@@ -19,7 +19,7 @@ import {
     inputParameters,
     parameterIdentifier,
 } from "../../analysis/param-structure.js";
-import { renderTsType } from "../../analysis/ts-type.js";
+import { renderParameterTsType, renderTsType } from "../../analysis/ts-type.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";
@@ -86,12 +86,7 @@ type PlanArgsContext = {
     folded: Set<number>;
 };
 
-const memberName = (girName: string): string => {
-    const camel = camelCase(girName);
-
-    return /^\d/.test(camel) ? `_${camel}` : camel;
-};
-
+const memberName = (girName: string): string => escapeIdentifierStart(camelCase(girName));
 const methodExportName = (fn: GirFunction): string => memberName(fn.name);
 
 const arrayLengthArgument = (source: GirParameter, sourceIndex: number): string => {
@@ -125,7 +120,7 @@ const parameterAnnotation = (context: ModuleContext, fn: GirFunction, parameter:
         return comparator;
     }
 
-    const base = renderTsType(context, parameter.type, parameter.nullable);
+    const base = renderParameterTsType(context, parameter.type, parameter.nullable);
 
     return requiresClosureAnnotation(context, fn, parameter) ? closureAnnotation(context, base) : base;
 };

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

@@ -1,21 +1,14 @@
-import { camelCase, sourceStringLiteral, toCamelIdentifier } from "@gtkx/utils";
+import { sourceStringLiteral, toCamelIdentifier } from "@gtkx/utils";
 import type { GirFunction } from "../../gir/function.js";
 import type { TypeId } from "../../gir/type-id.js";
 import type { ModuleContext } from "../../writer/context.js";
 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 { comparisonContextFor } from "../../writer/comparison-context.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 AccessorTypes = {
-    readType: string;
-    writeType: string;
-};
+import { methodExportName } from "./method.js";
 
 type InheritedAccessorTypes = {
     readType: string | undefined;
@@ -29,24 +22,17 @@ type ResolvedAccessor = {
     writeType: string;
     hasGetter: boolean;
     isWritable: boolean;
-    getterMember: string | undefined;
-    setterMember: string | undefined;
 };
 
 type PropertyAccessorArgs = {
     context: ModuleContext;
     property: GirProperty;
     claimedNames: Set<string>;
-    methodByName: Map<string, GirFunction>;
     inheritedTypes?: InheritedAccessorTypes | undefined;
     inheritedNames?: Set<string> | undefined;
 };
 
-type AccessorDelegate = { member: string; method: GirFunction };
-type AccessorDelegates = { getter: AccessorDelegate | undefined; setter: AccessorDelegate | undefined };
-type TypedDelegates = { types: AccessorTypes; delegates: AccessorDelegates };
-
-const NULLABLE_SUFFIX = " | null";
+const NON_NULLABLE_KINDS: Set<string> = new Set(["primitive", "enum"]);
 
 const isNullablePropertyType = (context: ModuleContext, type: TypeId | undefined): boolean => {
     if (type === undefined) {
@@ -59,141 +45,19 @@ const isNullablePropertyType = (context: ModuleContext, type: TypeId | undefined
         return true;
     }
 
-    if (resolved.kind === "primitive") {
-        return false;
-    }
-
-    if (resolved.kind === "enum") {
-        return false;
-    }
-
     if (resolved.kind === "alias") {
         return isNullablePropertyType(context, resolved.value.target);
     }
 
-    return true;
-};
-
-const resolveDelegate = (
-    args: PropertyAccessorArgs,
-    attribute: string | undefined,
-    member: string | undefined,
-    isDelegatable: (method: GirFunction) => boolean,
-): AccessorDelegate | undefined => {
-    const method = member !== undefined && attribute !== undefined ? args.methodByName.get(attribute) : undefined;
-
-    if (member === undefined || method === undefined || !isDelegatable(method)) {
-        return undefined;
-    }
-
-    return { member, method };
-};
-
-const resolveGetterDelegate = (args: PropertyAccessorArgs, jsName: string): AccessorDelegate | undefined => {
-    const { context, property, claimedNames } = args;
-    const member = delegateMember(property.getter, jsName, claimedNames);
-
-    return resolveDelegate(
-        args,
-        property.getter,
-        member,
-        (method) =>
-            inputParameters(context.library, method).length === 0 &&
-            !renderMethodReturnType(context, method).startsWith("["),
-    );
-};
-
-const resolveSetterDelegate = (
-    args: PropertyAccessorArgs,
-    jsName: string,
-    isWritable: boolean,
-): AccessorDelegate | undefined => {
-    const { context, property, claimedNames } = args;
-    const member = isWritable ? delegateMember(property.setter, jsName, claimedNames) : undefined;
-
-    return resolveDelegate(
-        args,
-        property.setter,
-        member,
-        (method) => inputParameters(context.library, method).length === 1,
-    );
-};
-
-const baseTypeName = (type: string): string =>
-    type.endsWith(NULLABLE_SUFFIX) ? type.slice(0, -NULLABLE_SUFFIX.length) : type;
-
-const areDelegateBaseTypesAgreeing = (
-    context: ModuleContext,
-    getter: AccessorDelegate | undefined,
-    setter: AccessorDelegate | undefined,
-): boolean => {
-    const setterParam = setter?.method.parameters[0];
-
-    if (setterParam === undefined || getter === undefined) {
-        return true;
-    }
-
-    const scratch = comparisonContextFor(context);
-    const read = baseTypeName(renderMethodReturnType(scratch, getter.method));
-    const written = baseTypeName(renderTsType(scratch, setterParam.type, false));
-
-    return read === written;
-};
-
-const resolveDelegates = (args: PropertyAccessorArgs, jsName: string, isWritable: boolean): AccessorDelegates => {
-    const getter = resolveGetterDelegate(args, jsName);
-    const setter = resolveSetterDelegate(args, jsName, isWritable);
-
-    if (areDelegateBaseTypesAgreeing(args.context, getter, setter)) {
-        return { getter, setter };
-    }
-
-    return { getter, setter: undefined };
+    return !NON_NULLABLE_KINDS.has(resolved.kind);
 };
 
 const declaredPropertyType = (context: ModuleContext, property: GirProperty): string =>
-    renderTsType(context, property.type, isNullablePropertyType(context, property.type));
-
-const resolveOwnTypes = (
-    context: ModuleContext,
-    property: GirProperty,
-    delegates: AccessorDelegates,
-): AccessorTypes => {
-    const getterMethod = delegates.getter?.method;
-    const setterParam = delegates.setter?.method.parameters[0];
-
-    return {
-        readType: getterMethod === undefined
-            ? declaredPropertyType(context, property)
-            : renderMethodReturnType(context, getterMethod),
-        writeType: setterParam === undefined
-            ? declaredPropertyType(context, property)
-            : renderTsType(context, setterParam.type, setterParam.nullable || setterParam.optional),
-    };
-};
-
-const isAssignableType = (source: string, target: string): boolean =>
-    source === target || baseTypeName(target) === source;
-
-const agreeingDelegates = (
-    delegates: AccessorDelegates,
-    ownTypes: AccessorTypes,
-    declaredTypes: AccessorTypes,
-): AccessorDelegates => ({
-    getter: isAssignableType(ownTypes.readType, declaredTypes.readType) ? delegates.getter : undefined,
-    setter: isAssignableType(declaredTypes.writeType, ownTypes.writeType) ? delegates.setter : undefined,
-});
-
-const resolveTypedDelegates = (args: PropertyAccessorArgs, resolved: AccessorDelegates): TypedDelegates => {
-    const ownTypes = resolveOwnTypes(args.context, args.property, resolved);
-
-    const types = {
-        readType: args.inheritedTypes?.readType ?? ownTypes.readType,
-        writeType: args.inheritedTypes?.writeType ?? ownTypes.writeType,
-    };
-
-    return { types, delegates: agreeingDelegates(resolved, ownTypes, types) };
-};
+    renderTsType(
+        context,
+        property.type,
+        property.defaultValue === "NULL" || isNullablePropertyType(context, property.type),
+    );
 
 const isSkippedAccessor = (args: PropertyAccessorArgs, jsName: string): boolean =>
     !args.property.introspectable ||
@@ -201,31 +65,28 @@ const isSkippedAccessor = (args: PropertyAccessorArgs, jsName: string): boolean
     args.inheritedNames?.has(jsName) === true ||
     jsName === "constructor";
 
+const isAccessorEmittable = (args: PropertyAccessorArgs, jsName: string, isWritable: boolean): boolean =>
+    !isSkippedAccessor(args, jsName) && (args.property.readable || isWritable);
+
 const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefined => {
     const { property } = args;
     const jsName = toCamelIdentifier(property.name);
-
-    if (isSkippedAccessor(args, jsName)) {
-        return undefined;
-    }
-
     const isWritable = isConstructableProperty(property) && !property.constructOnly;
-    const { types, delegates } = resolveTypedDelegates(args, resolveDelegates(args, jsName, isWritable));
-    const hasGetter = property.readable || delegates.getter !== undefined;
 
-    if (!hasGetter && !isWritable) {
+    if (!isAccessorEmittable(args, jsName, isWritable)) {
         return undefined;
     }
 
+    const declared = declaredPropertyType(args.context, property);
+    const hasGetter = property.readable;
+
     return {
         property,
         jsName,
-        readType: types.readType,
-        writeType: types.writeType,
+        readType: args.inheritedTypes?.readType ?? declared,
+        writeType: args.inheritedTypes?.writeType ?? declared,
         hasGetter,
         isWritable,
-        getterMember: delegates.getter?.member,
-        setterMember: delegates.setter?.member,
     };
 };
 
@@ -234,7 +95,6 @@ const resolveOwnerAccessor = (
     property: GirProperty,
     methods: GirFunction[],
 ): ResolvedAccessor | undefined => {
-    const methodByName: Map<string, GirFunction> = new Map();
     const claimedNames: Set<string> = new Set();
 
     for (const method of methods) {
@@ -242,11 +102,10 @@ const resolveOwnerAccessor = (
             continue;
         }
 
-        methodByName.set(method.name, method);
         claimedNames.add(methodExportName(method));
     }
 
-    return resolveAccessor({ context, property, claimedNames, methodByName });
+    return resolveAccessor({ context, property, claimedNames });
 };
 
 const resolveAccessorTypes = (
@@ -284,18 +143,15 @@ const renderResolvedPropertyAccessor = (
     property: GirProperty,
     accessor: ResolvedAccessor,
 ): string => {
-    const { jsName, readType, writeType, hasGetter, isWritable, setterMember } = accessor;
+    const { jsName, readType, writeType, hasGetter, isWritable } = accessor;
     const blocks: string[] = [];
 
     if (hasGetter) {
-        blocks.push(renderBlock(`get ${jsName}(): ${readType}`, renderGetterBody(context, property, accessor)));
+        blocks.push(renderBlock(`get ${jsName}(): ${readType}`, renderGenericGetBody(context, property, readType)));
     }
 
     if (isWritable) {
-        const setterBody =
-            setterMember === undefined ? renderGenericSetBody(context, property) : `this.${setterMember}(value);`;
-
-        blocks.push(renderBlock(`set ${jsName}(value: ${writeType})`, setterBody));
+        blocks.push(renderBlock(`set ${jsName}(value: ${writeType})`, renderGenericSetBody(context, property)));
     }
 
     return `${propertyDoc(property)}${blocks.join("\n\n")}`;
@@ -347,33 +203,6 @@ const renderGenericSetBody = (context: ModuleContext, property: GirProperty): st
     return `setObjectProperty(this, ${sourceStringLiteral(property.name)}, ${descriptor}, value);`;
 };
 
-const renderGetterBody = (context: ModuleContext, property: GirProperty, accessor: ResolvedAccessor): string =>
-    accessor.getterMember === undefined
-        ? renderGenericGetBody(context, property, accessor.readType)
-        : `return this.${accessor.getterMember}();`;
-
-const delegateMember = (
-    attribute: string | undefined,
-    accessorName: string,
-    claimedNames: Set<string>,
-): string | undefined => {
-    if (attribute === undefined) {
-        return undefined;
-    }
-
-    const member = camelCase(attribute);
-
-    if (member === accessorName) {
-        return undefined;
-    }
-
-    if (!claimedNames.has(member)) {
-        return undefined;
-    }
-
-    return member;
-};
-
 export {
     propertyDoc,
     resolveAccessor,

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

@@ -121,9 +121,9 @@ const renderRecordConstructor = (context: ModuleContext, spec: RecordConstructor
 
     const statements = [
         ...superCall,
-        `const handle = alloc(${allocArgs(context, record, size).join(", ")});`,
+        `const __handle = alloc(${allocArgs(context, record, size).join(", ")});`,
         ...renderFieldWrites(context, slots),
-        "setHandle(this, handle);",
+        "setHandle(this, __handle);",
     ];
 
     return renderBlock(`constructor(props: ${className}ConstructorProps = {})`, statements.join("\n"));
@@ -151,7 +151,7 @@ const renderFieldWrite = (context: ModuleContext, entry: WritableFieldSlot): str
     const write = emitFieldWrite(context, {
         descriptor,
         slot: entry.slot,
-        targetExpr: "handle",
+        targetExpr: "__handle",
         valueExpr: `props.${name}`,
     });