@gtkx/codegen 1.2.2 → 1.4.0

package/src/analysis/ts-type.ts

@@ -11,7 +11,8 @@ import {
     type ListType,
     type TypeId,
 } from "../gir/type-id.js";
-import { gtypeTsType } from "../store/gi/gtype-binding.js";
+import { gtypeParamTsType, gtypeTsType } from "../store/gi/gtype-binding.js";
+import { isValueTypeName } from "../store/gi/param-marshal.js";
 import { isByteSequence } from "./type-shape.js";
 
 type ReferenceName = {
@@ -27,6 +28,12 @@ type TsTypeTarget = {
     renderGtype: () => string;
 };
 
+type ModuleTypeOptions = {
+    byteArrayType: string;
+    isValueWidened: boolean;
+    isGtypeWidened: boolean;
+};
+
 const BYTE_ARRAY_TYPE = "Uint8Array";
 const BYTE_ARRAY_INPUT_TYPE = "Uint8Array | number[]";
 const NUMBER_ARRAY_TYPE = "number[]";
@@ -101,6 +108,8 @@ const renderContainerType = (
     return renderSequenceType(library, target, type);
 };
 
+const parenthesizeUnion = (rendered: string): string => (rendered.includes(" | ") ? `(${rendered})` : rendered);
+
 const renderSequenceType = (library: Library, target: TsTypeTarget, type: CArrayType | ListType): string => {
     if (type.kind === "carray" && hasUnknownArrayLength(type)) {
         return "number";
@@ -110,7 +119,7 @@ const renderSequenceType = (library: Library, target: TsTypeTarget, type: CArray
         return target.byteArrayType;
     }
 
-    return `${renderBaseType(library, target, type.element)}[]`;
+    return `${parenthesizeUnion(renderBaseType(library, target, type.element))}[]`;
 };
 
 const renderNamedType = (
@@ -128,30 +137,55 @@ const renderNamedType = (
 const getByteArrayType = (library: Library): string =>
     library.isByteArrayTyped ? BYTE_ARRAY_TYPE : NUMBER_ARRAY_TYPE;
 
-const moduleTarget = (context: ModuleContext, byteArrayType: string): TsTypeTarget => ({
+const renderNamedModuleType = (context: ModuleContext, name: ReferenceName, isValueWidened: boolean): string => {
+    const qualified = context.qualify(name.namespaceName, name.typeName);
+
+    if (!isValueWidened || !isValueTypeName(name)) {
+        return qualified;
+    }
+
+    context.addRuntimeTypeImport("JsValue");
+
+    return `${qualified} | JsValue`;
+};
+
+const moduleTarget = (context: ModuleContext, options: ModuleTypeOptions): TsTypeTarget => ({
     containerStyle: "map",
     callbackType: "((...args: any[]) => any)",
-    byteArrayType,
-    renderNamed: (_resolved, name) => context.qualify(name.namespaceName, name.typeName),
-    renderGtype: () => gtypeTsType(context),
+    byteArrayType: options.byteArrayType,
+    renderNamed: (_resolved, name) => renderNamedModuleType(context, name, options.isValueWidened),
+    renderGtype: () => (options.isGtypeWidened ? gtypeParamTsType(context) : gtypeTsType(context)),
 });
 
 const renderModuleType = (
     context: ModuleContext,
     ref: TypeId | undefined,
     isNullable: boolean,
-    byteArrayType: string,
+    options: ModuleTypeOptions,
 ): string => {
-    const base = renderBaseType(context.library, moduleTarget(context, byteArrayType), ref);
+    const base = renderBaseType(context.library, moduleTarget(context, options), ref);
 
     return isNullable ? `${base} | null` : base;
 };
 
 const renderTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string =>
-    renderModuleType(context, ref, isNullable, getByteArrayType(context.library));
+    renderModuleType(context, ref, isNullable, {
+        byteArrayType: getByteArrayType(context.library),
+        isValueWidened: false,
+        isGtypeWidened: false,
+    });
 
-const renderParameterTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string =>
-    renderModuleType(context, ref, isNullable, BYTE_ARRAY_INPUT_TYPE);
+const renderParameterTsType = (
+    context: ModuleContext,
+    ref: TypeId | undefined,
+    isNullable = false,
+    isValueWidened = true,
+): string =>
+    renderModuleType(context, ref, isNullable, {
+        byteArrayType: BYTE_ARRAY_INPUT_TYPE,
+        isValueWidened,
+        isGtypeWidened: true,
+    });
 
 const recordTypeTarget = (
     library: Library,

package/src/compile.ts

@@ -76,7 +76,7 @@ const DECLARATION_EMIT = {
 };
 
 const MODULE_EMIT = {
-    removeComments: false,
+    removeComments: true,
 };
 
 const DECLARATION_OPTIONS = ts.convertCompilerOptionsFromJson(

package/src/docs/api-reference.ts

@@ -3,6 +3,7 @@ import type { GirClass } from "../gir/class.js";
 import type { GirFunction } from "../gir/function.js";
 import type { GirRecord } from "../gir/record.js";
 import { isEmittableEntity } from "../gir/emittable.js";
+import { externalPackageFor } from "../gir/external-namespaces.js";
 import { Library } from "../gir/library.js";
 import { type GirNamespace, namespaceDirectory } from "../gir/namespace.js";
 import { dedupeCallables, isEmittableCallable } from "../store/gi/callables.js";
@@ -26,6 +27,12 @@ type ApiReferenceOptions = {
     omittedProps?: OmittedProps;
     /** Describes GIR byte sequences as `Uint8Array` rather than `number[]`; defaults to false. */
     isByteArrayTyped?: boolean;
+    /** Describes what a `GObject.Value` a binding hands back holds, rather than the value itself; off by default. */
+    isValueUnwrapped?: boolean;
+    /** Describes promisified results of a throwing finish without their leading success boolean; off by default. */
+    isFinishTrimmed?: boolean;
+    /** Describes a handle-passing inout parameter as mutated in place rather than returned; off by default. */
+    isInoutInPlace?: boolean;
 };
 
 /** Narrows an `ApiReference.symbols` enumeration. */
@@ -373,7 +380,14 @@ class ApiReference {
         this.libraries = options.libraries;
         this.props = options.props ?? {};
         this.omittedProps = options.omittedProps ?? {};
-        this.library = Library.load(options.libraries, options.girPath, options.isByteArrayTyped === true);
+
+        this.library = Library.load(options.libraries, options.girPath, {
+            isByteArrayTyped: options.isByteArrayTyped === true,
+            isValueUnwrapped: options.isValueUnwrapped === true,
+            isFinishTrimmed: options.isFinishTrimmed === true,
+            isInoutInPlace: options.isInoutInPlace === true,
+        });
+
         this.elementContext = { library: this.library, linkFor: (): string | undefined => undefined };
         this.buildIndex();
     }
@@ -399,6 +413,10 @@ class ApiReference {
 
     private buildIndex(): void {
         for (const namespace of this.library.namespaces.values()) {
+            if (externalPackageFor(namespace.name) !== undefined) {
+                continue;
+            }
+
             this.indexNamespace(namespace);
         }
 
@@ -475,7 +493,7 @@ class ApiReference {
         const lower = name.toLowerCase();
 
         for (const namespace of this.library.namespaces.values()) {
-            if (namespace.name.toLowerCase() === lower) {
+            if (namespace.name.toLowerCase() === lower && externalPackageFor(namespace.name) === undefined) {
                 return namespace;
             }
         }

package/src/docs/pipeline.ts

@@ -39,6 +39,9 @@ type DocsOptions = {
     omittedProps?: OmittedProps;
     isForced?: boolean;
     isByteArrayTyped?: boolean;
+    isValueUnwrapped?: boolean;
+    isFinishTrimmed?: boolean;
+    isInoutInPlace?: boolean;
 };
 
 type DocsManifest = {
@@ -259,7 +262,11 @@ const giInputs = (options: DocsOptions, girFiles: string[]): GiInputs => ({
     girFiles,
     libraries: options.libraries,
     girPath: options.girPath,
+    storeVersion: undefined,
     isByteArrayTyped: options.isByteArrayTyped === true,
+    isValueUnwrapped: options.isValueUnwrapped === true,
+    isFinishTrimmed: options.isFinishTrimmed === true,
+    isInoutInPlace: options.isInoutInPlace === true,
 });
 
 const assertOwnedOutDir = (options: DocsOptions, manifest: DocsManifest | undefined): void => {
@@ -344,7 +351,14 @@ const writeDocs = (options: DocsOptions): DocsResult => {
     }
 
     assertOwnedOutDir(options, previous);
-    const library = Library.load(options.libraries, options.girPath, options.isByteArrayTyped === true);
+
+    const library = Library.load(options.libraries, options.girPath, {
+        isByteArrayTyped: options.isByteArrayTyped === true,
+        isValueUnwrapped: options.isValueUnwrapped === true,
+        isFinishTrimmed: options.isFinishTrimmed === true,
+        isInoutInPlace: options.isInoutInPlace === true,
+    });
+
     const { pages, namespaces } = generatePages(options, input.basePath, library);
     clearOutDir(options, previous);
     mkdirSync(options.outDir, { recursive: true });

package/src/fingerprint.ts

@@ -1,9 +1,10 @@
-import { sortStrings } from "@gtkx/utils";
-import { createHash } from "node:crypto";
+import { createHash, type Hash } from "node:crypto";
 import { type Dirent, existsSync, readdirSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import packageManifest from "../package.json" with { type: "json" };
+import { EXTERNAL_NAMESPACES } from "./gir/external-namespaces.js";
 import { arrayGuard, hasFields, isNumber, isString, optionalGuard } from "./guards.js";
 import { readJsonFile } from "./json.js";
 
@@ -11,7 +12,11 @@ type GiInputs = {
     girFiles: string[];
     libraries: string[];
     girPath: string[];
+    storeVersion: string | undefined;
     isByteArrayTyped: boolean;
+    isValueUnwrapped: boolean;
+    isFinishTrimmed: boolean;
+    isInoutInPlace: boolean;
 };
 
 type GiFingerprint = {
@@ -36,6 +41,7 @@ type DocsFingerprint = {
 
 type JsxFingerprintInput = {
     reactVersion: string;
+    reactSubexports: string[];
     components: Record<string, ModuleExport>;
     lazyElements: string[];
     props: Record<string, ModuleExport>;
@@ -47,25 +53,146 @@ type JsxFingerprint = {
     intrinsicElementCount: number;
 };
 
+type InstalledManifest = { name: string; version: string };
+
 const FINGERPRINT_FILENAME = ".codegen-fingerprint.json";
-const CODEGEN_VERSION: string = packageManifest.version;
-const OVERRIDES_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "overrides");
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const OVERRIDES_ROOT = join(PACKAGE_ROOT, "overrides");
+const requireFromCodegen = createRequire(import.meta.url);
+const codegenHashCache: Map<string, string> = new Map();
+
+const compareOrdinal = (a: string, b: string): number => {
+    if (a < b) {
+        return -1;
+    }
+
+    return a > b ? 1 : 0;
+};
 
-const sortAlpha = (values: string[]): string => sortStrings(values).join(",");
+const sortOrdinal = (values: string[]): string[] => values.toSorted(compareOrdinal);
+const sortAlpha = (values: string[]): string => sortOrdinal(values).join(",");
 
-const overrideFiles = (): string[] => {
-    if (!existsSync(OVERRIDES_ROOT)) {
+const filesUnder = (root: string): string[] => {
+    if (!existsSync(root)) {
         return [];
     }
 
-    return readdirSync(OVERRIDES_ROOT, { recursive: true, withFileTypes: true })
+    return readdirSync(root, { recursive: true, withFileTypes: true })
         .filter((entry: Dirent) => entry.isFile())
         .map((entry: Dirent) => join(entry.parentPath, entry.name));
 };
 
+const hashTree = (hash: Hash, label: string, root: string): void => {
+    const files = sortOrdinal(filesUnder(root));
+
+    for (const file of files) {
+        hash.update("\n");
+        hash.update(join(label, relative(root, file)));
+        hash.update("\0");
+        hash.update(readFileSync(file));
+    }
+};
+
+const isInstalledManifest = (value: unknown): value is InstalledManifest =>
+    hasFields<InstalledManifest>(value, { name: isString, version: isString });
+
+const tryResolve = (specifier: string): string | undefined => {
+    try {
+        return requireFromCodegen.resolve(specifier);
+    } catch {
+        return undefined;
+    }
+};
+
+const manifestVersion = (path: string | undefined, name: string): string | undefined => {
+    if (path === undefined) {
+        return undefined;
+    }
+
+    const manifest = readJsonFile(path);
+
+    return isInstalledManifest(manifest) && manifest.name === name ? manifest.version : undefined;
+};
+
+const packageRootFor = (name: string): string | undefined => {
+    const entry = tryResolve(name);
+
+    if (entry === undefined) {
+        return undefined;
+    }
+
+    for (let directory = dirname(entry); directory !== dirname(directory); directory = dirname(directory)) {
+        if (manifestVersion(join(directory, "package.json"), name) !== undefined) {
+            return directory;
+        }
+    }
+
+    return undefined;
+};
+
+const installedVersion = (name: string): string | undefined => {
+    const direct = manifestVersion(tryResolve(`${name}/package.json`), name);
+
+    if (direct !== undefined) {
+        return direct;
+    }
+
+    const root = packageRootFor(name);
+
+    return root === undefined ? undefined : manifestVersion(join(root, "package.json"), name);
+};
+
+const dependencyVersions = (): string[] =>
+    sortOrdinal(
+        Object.entries(packageManifest.dependencies)
+            .filter(([name]) => !name.startsWith("@types/"))
+            .map(([name, range]) => `${name}@${installedVersion(name) ?? range}`),
+    );
+
+const hashPackageCode = (hash: Hash, label: string, root: string): void => {
+    const source = join(root, "src");
+
+    if (existsSync(source)) {
+        hashTree(hash, join(label, "src"), source);
+
+        return;
+    }
+
+    hashTree(hash, join(label, "dist"), join(root, "dist"));
+};
+
+const computeCodegenHash = (): string => {
+    const hash = createHash("sha256");
+    hash.update(dependencyVersions().join(","));
+    hashPackageCode(hash, "codegen", PACKAGE_ROOT);
+    hashTree(hash, "overrides", OVERRIDES_ROOT);
+    const utilsRoot = packageRootFor("@gtkx/utils");
+
+    if (utilsRoot !== undefined) {
+        hashPackageCode(hash, "@gtkx/utils", utilsRoot);
+    }
+
+    return hash.digest("hex");
+};
+
+const codegenHash = (): string => {
+    const cached = codegenHashCache.get("codegen");
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const value = computeCodegenHash();
+    codegenHashCache.set("codegen", value);
+
+    return value;
+};
+
 const hashGi = (inputs: GiInputs): string => {
     const hash = createHash("sha256");
-    hash.update(CODEGEN_VERSION);
+    hash.update(codegenHash());
+    hash.update("\n");
+    hash.update(JSON.stringify(EXTERNAL_NAMESPACES));
     hash.update("\n");
     hash.update(sortAlpha(inputs.libraries));
     hash.update("\n");
@@ -73,9 +200,16 @@ const hashGi = (inputs: GiInputs): string => {
     hash.update("\n");
     hash.update(String(inputs.isByteArrayTyped));
     hash.update("\n");
-    const hashedFiles = sortStrings([...inputs.girFiles, ...overrideFiles()]);
+    hash.update(String(inputs.isValueUnwrapped));
+    hash.update("\n");
+    hash.update(String(inputs.isFinishTrimmed));
+    hash.update("\n");
+    hash.update(String(inputs.isInoutInPlace));
+    hash.update("\n");
+    hash.update(String(inputs.storeVersion));
+    const girFiles = sortOrdinal(inputs.girFiles);
 
-    for (const file of hashedFiles) {
+    for (const file of girFiles) {
         hash.update("\n");
         hash.update(file);
         hash.update("\0");
@@ -161,19 +295,20 @@ const isDocsOutputFresh = (outDir: string, inputs: GiInputs, input: DocsFingerpr
 };
 
 const serializeModuleExports = (map: Record<string, ModuleExport>): [string, string, string][] =>
-    sortStrings(Object.keys(map)).map((type) => [type, map[type]?.module ?? "", map[type]?.export ?? ""]);
+    sortOrdinal(Object.keys(map)).map((type) => [type, map[type]?.module ?? "", map[type]?.export ?? ""]);
 
 const serializeOmittedProps = (map: Record<string, string[]>): [string, string][] =>
-    sortStrings(Object.keys(map)).map((type) => [type, sortAlpha(map[type] ?? [])]);
+    sortOrdinal(Object.keys(map)).map((type) => [type, sortAlpha(map[type] ?? [])]);
 
 const hashJsx = (input: JsxFingerprintInput): string =>
     createHash("sha256")
         .update(
             JSON.stringify([
-                CODEGEN_VERSION,
+                codegenHash(),
                 input.reactVersion,
+                sortOrdinal(input.reactSubexports),
                 serializeModuleExports(input.components),
-                sortStrings(input.lazyElements),
+                sortOrdinal(input.lazyElements),
                 serializeModuleExports(input.props),
                 serializeOmittedProps(input.omittedProps),
             ]),

package/src/gi.ts

@@ -1,8 +1,10 @@
 import type { Library } from "./gir/library.js";
 import type { StoreOptions } from "./store/store-fs.js";
 import { computeGiFingerprint } from "./fingerprint.js";
+import { externalPackageFor } from "./gir/external-namespaces.js";
 import { namespaceDirectory } from "./gir/namespace.js";
-import { type GiNamespaceInput, writeGiStore } from "./store/gi-store.js";
+import { type GiExternalNamespaceInput, type GiNamespaceInput, writeGiStore } from "./store/gi-store.js";
+import { collectGeneratedLibraries } from "./store/gi/generated-libraries.js";
 import { generateNamespaceModule } from "./store/gi/pipeline.js";
 
 type GiCodegenOptions = {
@@ -10,25 +12,62 @@ type GiCodegenOptions = {
     libraries: string[];
     girPath: string[];
     isByteArrayTyped: boolean;
+    isValueUnwrapped: boolean;
+    isFinishTrimmed: boolean;
+    isInoutInPlace: boolean;
 };
 
-const runGiCodegen = (library: Library, options: GiCodegenOptions): number => {
-    const { gi, libraries, girPath, isByteArrayTyped } = options;
+type SplitNamespaces = {
+    namespaces: GiNamespaceInput[];
+    externalNamespaces: GiExternalNamespaceInput[];
+};
+
+const splitNamespaces = (library: Library): SplitNamespaces => {
+    const namespaces: GiNamespaceInput[] = [];
+    const externalNamespaces: GiExternalNamespaceInput[] = [];
+
+    for (const namespace of library.namespaces.values()) {
+        const packageName = externalPackageFor(namespace.name);
+
+        if (packageName !== undefined) {
+            externalNamespaces.push({
+                directory: namespaceDirectory(namespace),
+                packageName,
+                girFile: namespace.girFile,
+            });
+
+            continue;
+        }
 
-    const namespaces: GiNamespaceInput[] = Array.from(library.namespaces.values(), (namespace) => ({
-        directory: namespaceDirectory(namespace),
-        rawSource: generateNamespaceModule(namespace, library),
-        girFile: namespace.girFile,
-    }));
+        namespaces.push({
+            directory: namespaceDirectory(namespace),
+            rawSource: generateNamespaceModule(namespace, library),
+            girFile: namespace.girFile,
+        });
+    }
+
+    return { namespaces, externalNamespaces };
+};
+
+const runGiCodegen = (library: Library, options: GiCodegenOptions): number => {
+    const { gi, libraries, girPath, isByteArrayTyped, isValueUnwrapped, isFinishTrimmed, isInoutInPlace } = options;
+    const { namespaces, externalNamespaces } = splitNamespaces(library);
 
     const fingerprint = computeGiFingerprint({
         girFiles: library.girFiles,
         libraries: [...libraries],
         girPath: [...girPath],
+        storeVersion: gi.version,
         isByteArrayTyped,
+        isValueUnwrapped,
+        isFinishTrimmed,
+        isInoutInPlace,
     });
 
-    writeGiStore(gi, namespaces, fingerprint);
+    writeGiStore(gi, namespaces, externalNamespaces, {
+        fingerprint,
+        libraries: collectGeneratedLibraries(library.namespaces, libraries),
+    });
 
     return library.namespaces.size;
 };

package/src/gir/external-namespaces.ts

@@ -0,0 +1,8 @@
+type ExternalNamespace = { namespace: string; packageName: string };
+
+const EXTERNAL_NAMESPACES: ExternalNamespace[] = [{ namespace: "cairo", packageName: "@gtkx/cairo" }];
+
+const externalPackageFor = (namespaceName: string): string | undefined =>
+    EXTERNAL_NAMESPACES.find((entry) => entry.namespace === namespaceName)?.packageName;
+
+export { EXTERNAL_NAMESPACES, externalPackageFor, type ExternalNamespace };

package/src/gir/finish-overrides.ts

@@ -0,0 +1,5 @@
+const FUNCTIONS_MISSING_FINISH_FUNC: Map<string, string> = new Map([
+    ["g_file_replace_contents_bytes_async", "replace_contents_finish"],
+]);
+
+export { FUNCTIONS_MISSING_FINISH_FUNC };

package/src/gir/function.ts

@@ -1,9 +1,12 @@
 import type { GirAnnotations } from "./annotations.js";
 import type { ParseContext } from "./type-id.js";
 import { type CursorParameterNames, PARAMETERS_MISSING_ARRAY_EXTENT } from "./cursor-overrides.js";
+import { FUNCTIONS_MISSING_FINISH_FUNC } from "./finish-overrides.js";
+import { HIDDEN_SYMBOLS } from "./hidden-symbols.js";
 import { PARAMETERS_MISSING_NULLABLE_ANNOTATION } from "./nullable-overrides.js";
 import { type GirParameter, type GirReturnValue, parameterFromNode, parseCallable } from "./parameter.js";
 import { attr, getChild, type RawNode } from "./parse.js";
+import { RETURNS_MISSING_UCS4_ARRAY_TYPE } from "./ucs4-overrides.js";
 
 /** A callable declared by a GIR namespace, class, or record: a function, a method, or a constructor. */
 type GirFunction = {
@@ -17,13 +20,16 @@ type GirFunction = {
     cIdentifier: string | undefined;
     /** Whether the C function takes a trailing `GError` out parameter and can fail. */
     throws: boolean;
-    /** Whether the GIR marks the callable as introspectable, and so bindable. */
+    /** Whether the callable is bindable: the GIR marks it introspectable and GTKX does not hide it. */
     introspectable: boolean;
     /** Qualified `Type.member` the GIR redirects the callable to, from its `moved-to` annotation. */
     movedTo: string | undefined;
     /** Name of the callable that shadows this one, from the GIR's `shadowed-by` annotation. */
     shadowedBy: string | undefined;
-    /** Name of the callable that completes this asynchronous one, from the GIR's `glib:finish-func`. */
+    /**
+     * Name of the callable that completes this asynchronous one, from the GIR's `glib:finish-func`
+     * or a GTKX override for a GIR that lacks the annotation.
+     */
     finishFunc: string | undefined;
     /** The instance the callable is invoked on, absent for constructors and namespace-level functions. */
     instance: GirParameter | undefined;
@@ -84,20 +90,52 @@ const bindMissingArrayExtent = (fn: GirFunction): GirFunction => {
     return fn;
 };
 
+const bindMissingUcs4ReturnArray = (fn: GirFunction, context: ParseContext): GirFunction => {
+    if (fn.cIdentifier !== undefined && RETURNS_MISSING_UCS4_ARRAY_TYPE.has(fn.cIdentifier)) {
+        fn.returnValue.type = context.addContainer({
+            kind: "carray",
+            element: context.addPrimitive("unichar"),
+            elementCType: "gunichar",
+            arrayCType: "gunichar*",
+            lengthParameterIndex: undefined,
+            fixedSize: undefined,
+            isZeroTerminated: true,
+        });
+    }
+
+    return fn;
+};
+
+const annotatedFinishFunc = (node: RawNode, cIdentifier: string | undefined): string | undefined => {
+    const annotated = attr(node, "glib:finish-func");
+
+    if (annotated !== undefined) {
+        return annotated;
+    }
+
+    return cIdentifier === undefined ? undefined : FUNCTIONS_MISSING_FINISH_FUNC.get(cIdentifier);
+};
+
+const isHiddenSymbol = (cIdentifier: string | undefined): boolean =>
+    cIdentifier !== undefined && HIDDEN_SYMBOLS.has(cIdentifier);
+
 const functionFromNode = (node: RawNode, context: ParseContext): GirFunction => {
     const instanceNode = getChild(getChild(node, "parameters"), "instance-parameter");
-
-    return bindMissingArrayExtent(
-        relaxMissingNullable({
-            ...parseCallable(node, context),
-            name: attr(node, "shadows") ?? attr(node, "name") ?? "",
-            cIdentifier: attr(node, "c:identifier"),
-            movedTo: attr(node, "moved-to"),
-            shadowedBy: attr(node, "shadowed-by"),
-            finishFunc: attr(node, "glib:finish-func"),
-            instance: instanceNode === undefined ? undefined : parameterFromNode(instanceNode, context),
-        }),
-    );
+    const callable = parseCallable(node, context);
+    const cIdentifier = attr(node, "c:identifier");
+
+    const fn: GirFunction = {
+        ...callable,
+        introspectable: callable.introspectable && !isHiddenSymbol(cIdentifier),
+        name: attr(node, "shadows") ?? attr(node, "name") ?? "",
+        cIdentifier,
+        movedTo: attr(node, "moved-to"),
+        shadowedBy: attr(node, "shadowed-by"),
+        finishFunc: annotatedFinishFunc(node, cIdentifier),
+        instance: instanceNode === undefined ? undefined : parameterFromNode(instanceNode, context),
+    };
+
+    return bindMissingUcs4ReturnArray(bindMissingArrayExtent(relaxMissingNullable(fn)), context);
 };
 
 export { functionFromNode, type GirFunction };

package/src/gir/hidden-symbols.ts

@@ -0,0 +1,39 @@
+const HIDDEN_SYMBOLS: Set<string> = new Set([
+    "g_action_map_add_action_entries",
+    "g_ascii_dtostr",
+    "g_ascii_formatd",
+    "g_file_info_set_attribute",
+    "g_file_set_attribute",
+    "g_log_set_writer_func",
+    "g_object_get_data",
+    "g_object_get_qdata",
+    "g_object_set_data",
+    "g_object_set_data_full",
+    "g_object_set_qdata",
+    "g_object_set_qdata_full",
+    "g_object_steal_data",
+    "g_object_steal_qdata",
+    "g_param_spec_get_qdata",
+    "g_param_spec_set_qdata",
+    "g_param_spec_set_qdata_full",
+    "g_param_spec_steal_qdata",
+    "g_ref_string_acquire",
+    "g_ref_string_length",
+    "g_ref_string_new",
+    "g_ref_string_new_intern",
+    "g_ref_string_new_len",
+    "g_ref_string_release",
+    "g_stpcpy",
+    "g_strcanon",
+    "g_strchomp",
+    "g_strchug",
+    "g_strdelimit",
+    "g_strdown",
+    "g_strreverse",
+    "g_strup",
+    "g_thread_exit",
+    "g_thread_new",
+    "g_thread_try_new",
+]);
+
+export { HIDDEN_SYMBOLS };