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

package/src/react/element-config.ts

@@ -1,16 +1,19 @@
-import type { ModuleExport } from "@gtkx/react/config";
+import type { ModuleExport } from "@gtkx/react/internal";
 import { readdirSync } from "node:fs";
 import type { OmittedProps } from "../store/jsx/omitted-props.js";
 
-/** The codegen-relevant subset of a React element config; behaviors are ignored at codegen time. */
-type BuiltinElement = { component?: ModuleExport; lazy?: boolean; props?: ModuleExport; omitProps?: string[] };
+type BuiltinElement = { component?: ModuleExport; isLazy?: boolean; props?: ModuleExport; omittedProps?: string[] };
 
 /** The framework's built-in element config, split into the maps codegen consumes. */
 type BuiltinElements = {
+    /** Component wrappers keyed by GLib type name; an element without one inherits its nearest ancestor's. */
     components: Record<string, ModuleExport>;
+    /** GLib type names with no GObject of their own, exported as elements that drop their construct-only props. */
     lazyElements: string[];
+    /** Base props interfaces the generated element props extend, keyed by GLib type name. */
     props: Record<string, ModuleExport>;
-    omitProps: OmittedProps;
+    /** Props left out of the generated element props, keyed by GLib type name. */
+    omittedProps: OmittedProps;
 };
 
 const CONFIG_ENTRYPOINT = "config";
@@ -29,10 +32,6 @@ const presentNamespaceDirs = (giStoreDir: string): Set<string> => {
     return dirs;
 };
 
-/**
- * The clean, reconciler-free `@gtkx/react` config entrypoints to import: the base `config` entry plus
- * each namespace's `<ns>/config` entry whose GIR namespace is present in the gi store.
- */
 const configEntrypoints = (reactSubexports: string[], present: Set<string>): string[] =>
     reactSubexports.filter((sub) => {
         if (sub === CONFIG_ENTRYPOINT) {
@@ -61,30 +60,34 @@ const applyBuiltinElement = (target: BuiltinElements, type: string, config: Buil
         target.props[type] = config.props;
     }
 
-    if (config.omitProps !== undefined) {
-        target.omitProps[type] = [...(target.omitProps[type] ?? []), ...config.omitProps];
+    if (config.omittedProps !== undefined) {
+        target.omittedProps[type] = [...(target.omittedProps[type] ?? []), ...config.omittedProps];
     }
 
-    if (config.lazy === true) {
+    if (config.isLazy === true) {
         target.lazyElements.push(type);
     }
 };
 
-/**
- * Reads the framework's built-in element config by importing the freshly linked `@gtkx/react` config
- * entrypoints. These are reconciler-free, so importing them resolves `@gtkx/gi` but never `virtual:gtkx-config`;
- * it must run only after the gi store has been linked.
- */
 const collectBuiltinElements = (target: BuiltinElements, elements: Record<string, BuiltinElement>): void => {
     for (const [type, config] of Object.entries(elements)) {
         applyBuiltinElement(target, type, config);
     }
 };
 
+/**
+ * Reads the framework's built-in element config by importing the `config` entrypoints of the installed
+ * `@gtkx/react`, skipping the per-namespace ones whose namespace the gi store does not carry. Those
+ * entrypoints are reconciler-free, so importing them resolves `@gtkx/gi` but never `virtual:gtkx-config`,
+ * which means this must run only after the gi store has been written and linked.
+ *
+ * @param reactSubexports Subexport names of the installed `@gtkx/react`, as `resolveStore` reports them.
+ * @param giStoreDir The gi store directory, whose subdirectories name the generated namespaces.
+ */
 const readBuiltinElements = async (reactSubexports: string[], giStoreDir: string): Promise<BuiltinElements> => {
     const present = presentNamespaceDirs(giStoreDir);
     const entrypoints = configEntrypoints(reactSubexports, present);
-    const result: BuiltinElements = { components: {}, lazyElements: [], props: {}, omitProps: {} };
+    const result: BuiltinElements = { components: {}, lazyElements: [], props: {}, omittedProps: {} };
 
     for (const entrypoint of entrypoints) {
         collectBuiltinElements(result, await importBuiltinElements(entrypoint));
@@ -93,5 +96,5 @@ const readBuiltinElements = async (reactSubexports: string[], giStoreDir: string
     return result;
 };
 
-export { type ModuleExport } from "@gtkx/react/config";
-export { readBuiltinElements, type BuiltinElement, type BuiltinElements };
+export type { ModuleExport } from "@gtkx/react/internal";
+export { readBuiltinElements, type BuiltinElements };

package/src/runner.ts

@@ -1,15 +1,20 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import type { GiStoreOptions } from "./store/gi-store.js";
-import type { JsxStoreOptions } from "./store/jsx-store.js";
 import type { OmittedProps } from "./store/jsx/omitted-props.js";
+import type { StoreOptions } from "./store/store-fs.js";
 import { checkModules } from "./compile.js";
 import { isGiStoreFresh } from "./fingerprint.js";
 import { runGiCodegen } from "./gi.js";
 import { Library } from "./gir/library.js";
 import { generateGlModules, type GlGenerationReport } from "./khronos/pipeline.js";
 
-type ModuleExport = { module: string; export: string };
+/** A named export in a module, referenced as plain data (the module is never imported at runtime). */
+type ModuleExport = {
+    /** Specifier the export is imported from. */
+    module: string;
+    /** Identifier the module exports it under. */
+    export: string;
+};
 
 type GlCodegenOptions = {
     registryPath: string;
@@ -18,58 +23,71 @@ type GlCodegenOptions = {
     resolveFrom: string;
 };
 
+/** What to generate and where to write it. */
 type CodegenRunnerOptions = {
-    libraries?: string[];
-    girPath?: string[];
-    gi?: GiStoreOptions;
-    jsx?: JsxStoreOptions | undefined;
+    /** GIR library identifiers such as `"Gtk-4.0"`; a `"*"` selection must be expanded before it gets here. */
+    libraries: string[];
+    /** Directories to search for `.gir` files. */
+    girPath: string[];
+    /** Where to write and link the `@gtkx/gi` store. */
+    gi: StoreOptions;
+    /** Where to write and link the `@gtkx/jsx` store; omit to generate the gi store alone. */
+    jsx?: StoreOptions | undefined;
+    /** Subexport names of the installed `@gtkx/react`, whose element config shapes the jsx store. */
     reactSubexports?: string[];
+    /** Component wrappers the project layers over the built-ins, keyed by GLib type name. */
     userComponents?: Record<string, ModuleExport>;
+    /** GLib type names whose GObject their parent container creates, added to the framework's own. */
     userLazyElements?: string[];
+    /** Base props interfaces the project's elements extend, keyed by GLib type name. */
     userProps?: Record<string, ModuleExport>;
-    userOmitProps?: OmittedProps;
-    gl?: GlCodegenOptions;
-    force?: boolean;
+    /** Props the project drops from the generated element props, keyed by GLib type name. */
+    userOmittedProps?: OmittedProps;
+    /** Regenerates both stores even when their fingerprints are fresh. */
+    isForced?: boolean;
 };
 
+/** What a `runCodegen` run produced. */
 type CodegenRunnerResult = {
-    regenerated: boolean;
+    /** Whether either store was rewritten; false means both were already fresh. */
+    isRegenerated: boolean;
+    /** How many namespaces the gi store was written with, zero when it was already fresh. */
     namespaces: number;
+    /** How many JSX elements the jsx store binds, zero when no jsx store was requested. */
     intrinsicElements: number;
+    /** Wall-clock duration of the run, in milliseconds. */
     duration: number;
-    gl?: GlGenerationReport | undefined;
 };
 
 type StoreResult = {
-    regenerated: boolean;
+    isRegenerated: boolean;
     namespaces: number;
     intrinsicElements: number;
 };
 
 /**
- * Runs the `@gtkx` code generators, producing the `@gtkx/gi`, `@gtkx/jsx`, and `@gtkx/gl` bindings from the
- * configured GObject-introspection libraries and OpenGL registry. The gi store is regenerated only when its
- * fingerprint is stale unless `options.force` is set, then the jsx store is regenerated when the gi store or
- * the React element config changed; the OpenGL modules are regenerated whenever `options.gl` is provided.
+ * Writes and links a project's `@gtkx/gi` and `@gtkx/jsx` stores from the given GObject-Introspection
+ * libraries. The gi store is rewritten only when its GIR inputs changed, and the jsx store only when the gi
+ * store or the React element config changed, unless `options.isForced` is set. Pass the spread of
+ * `resolveStore(projectRoot)` for everything but `libraries` and `girPath`.
  *
- * @param options - What to generate and where to write it.
+ * @param options What to generate and where to write it.
  * @returns A summary of what was regenerated and how long the run took.
+ * @throws If `girPath` is empty, which would otherwise generate nothing and report success.
  */
 const runCodegen = async (options: CodegenRunnerOptions): Promise<CodegenRunnerResult> => {
     const start = Date.now();
-    const gl = options.gl === undefined ? undefined : emitGlModules(options.gl);
     const store = await emitStores(options);
 
     return {
-        regenerated: store.regenerated,
+        isRegenerated: store.isRegenerated,
         namespaces: store.namespaces,
         intrinsicElements: store.intrinsicElements,
         duration: Date.now() - start,
-        gl,
     };
 };
 
-const emitGlModules = (options: GlCodegenOptions): GlGenerationReport => {
+const runGlCodegen = (options: GlCodegenOptions): GlGenerationReport => {
     const { files, report } = generateGlModules({
         registryPath: options.registryPath,
         overrideExports: options.overrideExports,
@@ -97,24 +115,24 @@ const jsxUserOptions = (
     userComponents: Record<string, ModuleExport>;
     userLazyElements: string[];
     userProps: Record<string, ModuleExport>;
-    userOmitProps: OmittedProps;
+    userOmittedProps: OmittedProps;
 } => ({
     reactSubexports: options.reactSubexports ?? [],
     userComponents: options.userComponents ?? {},
     userLazyElements: options.userLazyElements ?? [],
     userProps: options.userProps ?? {},
-    userOmitProps: options.userOmitProps ?? {},
+    userOmittedProps: options.userOmittedProps ?? {},
 });
 
 const emitJsxStore = async (input: {
     options: CodegenRunnerOptions;
-    jsx: JsxStoreOptions;
-    gi: GiStoreOptions;
+    jsx: StoreOptions;
+    gi: StoreOptions;
     loadLibrary: () => Library;
-    giRegenerated: boolean;
+    isGiRegenerated: boolean;
     namespaces: number;
 }): Promise<StoreResult> => {
-    const { options, jsx, gi, loadLibrary, giRegenerated, namespaces } = input;
+    const { options, jsx, gi, loadLibrary, isGiRegenerated, namespaces } = input;
     const { runJsxCodegen } = await import("./jsx.js");
 
     const jsxResult = await runJsxCodegen({
@@ -122,12 +140,12 @@ const emitJsxStore = async (input: {
         jsx,
         giStoreDir: gi.storeDir,
         ...jsxUserOptions(options),
-        giRegenerated,
-        force: options.force === true,
+        isGiRegenerated,
+        isForced: options.isForced === true,
     });
 
     return {
-        regenerated: giRegenerated || jsxResult.regenerated,
+        isRegenerated: isGiRegenerated || jsxResult.isRegenerated,
         namespaces,
         intrinsicElements: jsxResult.intrinsicElementCount,
     };
@@ -135,35 +153,35 @@ const emitJsxStore = async (input: {
 
 const emitStoresWithConfig = async (config: {
     options: CodegenRunnerOptions;
-    gi: GiStoreOptions;
-    jsx: JsxStoreOptions | undefined;
+    gi: StoreOptions;
+    jsx: StoreOptions | undefined;
     libraries: string[];
     girPath: string[];
 }): Promise<StoreResult> => {
     const { options, gi, jsx, libraries, girPath } = config;
     let library: Library | undefined;
     const loadLibrary = (): Library => (library ??= Library.load(libraries, girPath));
-    const isGiRegenerated = options.force === true || !isGiStoreFresh(gi.storeDir, libraries, girPath);
+    const isGiRegenerated = options.isForced === true || !isGiStoreFresh(gi.storeDir, libraries, girPath);
 
     const namespaces = isGiRegenerated
         ? runGiCodegen(loadLibrary(), { gi, libraries, girPath })
         : 0;
 
     if (jsx === undefined) {
-        return { regenerated: isGiRegenerated, namespaces, intrinsicElements: 0 };
+        return { isRegenerated: isGiRegenerated, namespaces, intrinsicElements: 0 };
     }
 
-    return emitJsxStore({ options, jsx, gi, loadLibrary, giRegenerated: isGiRegenerated, namespaces });
+    return emitJsxStore({ options, jsx, gi, loadLibrary, isGiRegenerated, namespaces });
 };
 
 const emitStores = async (options: CodegenRunnerOptions): Promise<StoreResult> => {
     const { gi, jsx, libraries, girPath } = options;
 
-    if (gi === undefined || libraries === undefined || girPath === undefined) {
-        return { regenerated: false, namespaces: 0, intrinsicElements: 0 };
+    if (girPath.length === 0) {
+        throw new Error("codegen needs at least one GIR search path; pass the result of resolveGirPath");
     }
 
     return emitStoresWithConfig({ options, gi, jsx, libraries, girPath });
 };
 
-export { runCodegen, type GlCodegenOptions, type CodegenRunnerOptions, type CodegenRunnerResult };
+export { runCodegen, runGlCodegen, type CodegenRunnerOptions, type CodegenRunnerResult };

package/src/store/compile-store.ts

@@ -6,8 +6,7 @@ type CompileStoreParams = {
     storeDir: string;
     files: SourceModule[];
     packageName: string;
-    /** Declare `virtual:gtkx-config` for the typecheck, needed when it follows imports into `@gtkx/react` source. */
-    configEnv?: boolean;
+    requiresEnvReference?: boolean;
 };
 
 const EMIT_OPTIONS = {
@@ -32,14 +31,14 @@ const writeEnvReference = (storeDir: string): (() => void) => {
 const compileStore = (params: CompileStoreParams): void => {
     const fileNames = params.files.map((file) => file.fileName);
 
-    const removeEnvReference = params.configEnv === true
+    const removeEnvReference = params.requiresEnvReference === true
         ? writeEnvReference(params.storeDir)
         : (): void => undefined;
 
     try {
         compileProject({
             projectDir: params.storeDir,
-            fileNames: params.configEnv === true ? [ENV_REFERENCE_FILE, ...fileNames] : fileNames,
+            fileNames: params.requiresEnvReference === true ? [ENV_REFERENCE_FILE, ...fileNames] : fileNames,
             compilerOptions: EMIT_OPTIONS,
             label: `the generated ${params.packageName} store`,
         });

package/src/store/gi/callables.ts

@@ -34,7 +34,7 @@ type CallableMemberOptions = {
     resolveName: (callable: GirFunction) => string | undefined;
     isStatic: boolean;
     returnTypeOverride?: string | undefined;
-    allowRuntimeOverride?: boolean;
+    canUseRuntimeOverride?: boolean;
 };
 
 type StaticEntryOptions = {
@@ -159,9 +159,9 @@ const runtimeOverrideMember = (
     callable: GirFunction,
     name: string,
     doc: string,
-    allow: boolean | undefined,
+    canUseRuntimeOverride: boolean | undefined,
 ): string | undefined => {
-    if (allow !== true) {
+    if (canUseRuntimeOverride !== true) {
         return undefined;
     }
 
@@ -183,7 +183,7 @@ const renderCallableMember = (
 
     const { cIdentifier, name } = resolved;
     const doc = renderJsDoc(callable.doc);
-    const override = runtimeOverrideMember(callable, name, doc, options.allowRuntimeOverride);
+    const override = runtimeOverrideMember(callable, name, doc, options.canUseRuntimeOverride);
 
     if (override !== undefined) {
         return override;
@@ -240,7 +240,7 @@ const renderInstanceMethod = (
     renderCallableMember(context, callable, {
         resolveName: (member) => nameOverride ?? methodExportName(member),
         isStatic: false,
-        allowRuntimeOverride: true,
+        canUseRuntimeOverride: true,
     });
 
 const resolveInstanceMember = (

package/src/store/gi/constant.ts

@@ -6,8 +6,6 @@ import type { ModuleContext } from "../../writer/context.js";
 import { renderJsDoc } from "../../writer/doc.js";
 
 const TRUE_VALUES: Set<string> = new Set(["true", "1"]);
-// A `gint64`/`guint64` constant is typed `bigint`, and its decimal text does not survive a double:
-// G_MAXINT64 rounds to 2^63. The literal has to carry the BigInt suffix the type promises.
 const BIGINT_CATEGORIES: Set<PrimitiveCategory> = new Set(["bigint64", "biguint64", "gtype"]);
 
 const generateConstant = (context: ModuleContext, constant: GirConstant): void => {

package/src/store/gi/function.ts

@@ -32,13 +32,9 @@ const renderFnExpression = (context: ModuleContext, fn: GirFunction): string | u
     const params = planCallArgs(context, fn).map((arg) => arg.paramLiteral);
     const ret = renderReturnDescriptor(context, fn);
 
-    return tFn(library, fn.cIdentifier, { args: arrayLiteral(params), returns: ret, throws: fn.throws });
+    return tFn(library, fn.cIdentifier, { args: arrayLiteral(params), returns: ret, canThrow: fn.throws });
 };
 
-// `moved-to` names the type member this function is also reachable as, so the namespace-level copy
-// is a second export of one binding. Suppressing it is only right when that member is really
-// emitted: 15 of Gtk-4.0's 28 `moved-to` targets are enum or error-domain members codegen emits no
-// static for, and dropping those would delete API with nothing to replace it.
 const isMovedOntoEmittedMember = (context: ModuleContext, fn: GirFunction): boolean => {
     const [typeName, memberName] = fn.movedTo?.split(".") ?? [];
 

package/src/store/gi/method.ts

@@ -23,7 +23,7 @@ import { hasUnknownArrayLength, type TypeId } from "../../gir/type-id.js";
 import { itemComparatorArgDescriptors, itemComparatorTsType } from "./item-comparators.js";
 import { isCollectibleCallerOut, isHandlePassedInPlace, isHandlePassing } from "./param-marshal.js";
 
-type PromisifiedStep = { sawOptional: boolean; expression: string | undefined };
+type PromisifiedStep = { hasSeenOptional: boolean; expression: string | undefined };
 
 type PromisifyContext = {
     context: ModuleContext;
@@ -44,8 +44,8 @@ type CallArgPlan = {
 
 type ParamDescriptorOptions = {
     direction?: "out" | "inout";
-    callerAllocated?: boolean;
-    consumed?: boolean;
+    isCallerAllocated?: boolean;
+    isConsumed?: boolean;
 };
 
 type ArgIndexOptions = {
@@ -94,7 +94,7 @@ const renderInputParameters = (
     isOptionalExtra: (parameter: GirParameter) => boolean,
 ): string => {
     const parts: string[] = [];
-    let isSawOptional = false;
+    let hasSeenOptional = false;
 
     for (const { parameter, index } of inputParameters(context.library, fn)) {
         if (shouldSkip(parameter)) {
@@ -104,10 +104,10 @@ const renderInputParameters = (
         const name = parameterIdentifier(parameter, index);
 
         if (isParameterOptional(parameter, isOptionalExtra)) {
-            isSawOptional = true;
+            hasSeenOptional = true;
         }
 
-        parts.push(formatParameterPart(name, parameterAnnotation(context, fn, parameter), isSawOptional));
+        parts.push(formatParameterPart(name, parameterAnnotation(context, fn, parameter), hasSeenOptional));
     }
 
     return parts.join(", ");
@@ -139,36 +139,36 @@ const classifyPromisifiedParameter = (
     promisify: PromisifyContext,
     parameter: GirParameter,
     index: number,
-    state: { cancellableIndex: number; sawOptional: boolean },
+    state: { cancellableIndex: number; hasSeenOptional: boolean },
 ): PromisifiedStep => {
     if (parameter.isVarargs) {
-        return { sawOptional: state.sawOptional, expression: undefined };
+        return { hasSeenOptional: state.hasSeenOptional, expression: undefined };
     }
 
     if (index === state.cancellableIndex) {
-        return { sawOptional: true, expression: undefined };
+        return { hasSeenOptional: true, expression: undefined };
     }
 
     if (shouldSkipPromisifiedParameter(promisify, parameter, index)) {
-        return { sawOptional: state.sawOptional, expression: undefined };
+        return { hasSeenOptional: state.hasSeenOptional, expression: undefined };
     }
 
-    const isSawOptional = state.sawOptional || parameter.optional;
+    const hasSeenOptional = state.hasSeenOptional || parameter.optional;
 
-    return { sawOptional: isSawOptional, expression: promisifiedArgument(promisify, parameter, index, isSawOptional) };
+    return { hasSeenOptional, expression: promisifiedArgument(promisify, parameter, index, hasSeenOptional) };
 };
 
 const collectPromisifiedArguments = (promisify: PromisifyContext, cancellableIndex: number): string[] => {
     const expressions: string[] = [];
-    let isSawOptional = false;
+    let hasSeenOptional = false;
 
     for (const [index, parameter] of promisify.asyncFn.parameters.entries()) {
         const step = classifyPromisifiedParameter(promisify, parameter, index, {
             cancellableIndex,
-            sawOptional: isSawOptional,
+            hasSeenOptional,
         });
 
-        isSawOptional = step.sawOptional;
+        hasSeenOptional = step.hasSeenOptional;
 
         if (step.expression !== undefined) {
             expressions.push(step.expression);
@@ -298,12 +298,12 @@ const paramDescriptorLiteral = (descriptor: string, options: ParamDescriptorOpti
         parts.push(`direction: ${sourceStringLiteral(options.direction)}`);
     }
 
-    if (options.callerAllocated === true) {
-        parts.push("callerAllocated: true");
+    if (options.isCallerAllocated === true) {
+        parts.push("isCallerAllocated: true");
     }
 
-    if (options.consumed === true) {
-        parts.push("consumed: true");
+    if (options.isConsumed === true) {
+        parts.push("isConsumed: true");
     }
 
     return `{ ${parts.join(", ")} }`;
@@ -407,7 +407,7 @@ const planInoutArgument = (
     return planInoutParam(context, parameter, {
         index,
         argIndex: planContext.argIndex,
-        consumed: folded.has(index),
+        isConsumed: folded.has(index),
         lengthSource,
     });
 };
@@ -436,7 +436,7 @@ const planOutParam = (
     const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, argIndex);
 
     return {
-        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", consumed: isConsumed }),
+        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", isConsumed }),
         inputExpr: undefined,
     };
 };
@@ -474,7 +474,7 @@ const planCallerOut = (
         const classExpression = context.qualify(name.namespaceName, name.typeName);
 
         return {
-            paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", callerAllocated: true }),
+            paramLiteral: paramDescriptorLiteral(descriptor, { direction: "out", isCallerAllocated: true }),
             inputExpr: `new ${classExpression}()`,
         };
     }
@@ -488,17 +488,21 @@ const planInoutParam = (
     options: {
         index: number;
         argIndex: ArgIndexOptions;
-        consumed: boolean;
+        isConsumed: boolean;
         lengthSource?: { source: GirParameter; index: number } | undefined;
     },
 ): CallArgPlan => {
-    const { index, argIndex, consumed, lengthSource } = options;
+    const { index, argIndex, isConsumed, lengthSource } = options;
 
     if (isHandlePassedInPlace(context, parameter)) {
         const descriptor = renderDescriptor(context, parameter.type, "none", argIndex);
 
         return {
-            paramLiteral: paramDescriptorLiteral(descriptor, { direction: "inout", callerAllocated: true, consumed }),
+            paramLiteral: paramDescriptorLiteral(descriptor, {
+                direction: "inout",
+                isCallerAllocated: true,
+                isConsumed,
+            }),
             inputExpr: parameterIdentifier(parameter, index),
         };
     }
@@ -506,7 +510,7 @@ const planInoutParam = (
     const descriptor = renderDescriptor(context, parameter.type, parameter.transferOwnership, argIndex);
 
     return {
-        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "inout", consumed }),
+        paramLiteral: paramDescriptorLiteral(descriptor, { direction: "inout", isConsumed }),
         inputExpr:
             lengthSource === undefined
                 ? parameterCallExpression(context, parameter, index)
@@ -588,8 +592,6 @@ const collectionArgument = (
     return mapHandleExpression(name, isNullable);
 };
 
-// An array whose length nothing states is marshalled as the bare pointer it is, so there is nothing
-// to map over.
 const isMappableSequence = (context: ModuleContext, type: GirType | undefined): boolean => {
     if (type?.kind === "carray") {
         return !hasUnknownArrayLength(type) && isHandlePassing(context, type.element);

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

@@ -15,7 +15,7 @@ type ResolvedAccessor = {
     jsName: string;
     tsType: string;
     hasGetter: boolean;
-    writable: boolean;
+    isWritable: boolean;
     getterMember: string | undefined;
     getterMethod: GirFunction | undefined;
     setterMember: string | undefined;
@@ -136,8 +136,6 @@ const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefin
         return undefined;
     }
 
-    // `g_object_set_property` rejects a construct-only pspec with a critical and drops the write, so
-    // the property is settable at construction time only and must not advertise a setter.
     const isWritable = isConstructableProperty(property) && !property.constructOnly;
     const { member: getterMember, method: getterMethod } = resolveGetterDelegate(args, jsName);
     const { member: setterMember, method: setterMethod } = resolveSetterDelegate(args, jsName, isWritable);
@@ -150,7 +148,7 @@ const resolveAccessor = (args: PropertyAccessorArgs): ResolvedAccessor | undefin
     const ownType = resolveOwnType(context, property, getterMethod, setterMethod);
     const tsType = resolveTsType(args.inheritedType, ownType);
 
-    return { jsName, tsType, hasGetter, writable: isWritable, getterMember, getterMethod, setterMember };
+    return { jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember };
 };
 
 const resolveOwnerAccessor = (
@@ -197,7 +195,7 @@ const renderResolvedPropertyAccessor = (
     property: GirProperty,
     accessor: ResolvedAccessor,
 ): string => {
-    const { jsName, tsType, hasGetter, writable, getterMember, getterMethod, setterMember } = accessor;
+    const { jsName, tsType, hasGetter, isWritable, getterMember, getterMethod, setterMember } = accessor;
     const blocks: string[] = [];
 
     if (hasGetter) {
@@ -205,7 +203,7 @@ const renderResolvedPropertyAccessor = (
         blocks.push(renderBlock(`get ${jsName}(): ${tsType}`, getterBody));
     }
 
-    if (writable) {
+    if (isWritable) {
         const setterBody =
             setterMember === undefined ? renderGenericSetBody(context, property) : `this.${setterMember}(value);`;
 
@@ -219,10 +217,10 @@ const renderPropertyAccessor = (args: PropertyAccessorArgs): string | undefined
     withAccessor(args, (accessor) => renderResolvedPropertyAccessor(args.context, args.property, accessor));
 
 const renderPropertyAccessorSignature = (args: PropertyAccessorArgs): string | undefined =>
-    withAccessor(args, ({ jsName, tsType, hasGetter, writable }) => {
+    withAccessor(args, ({ jsName, tsType, hasGetter, isWritable }) => {
         const doc = renderJsDoc(args.property.doc);
 
-        if (hasGetter && writable) {
+        if (hasGetter && isWritable) {
             return `${doc}${jsName}: ${tsType};`;
         }