@ts-for-gir/lib 4.0.0-beta.25 → 4.0.0-beta.26

package/src/generators/generator.ts

@@ -0,0 +1,65 @@
+import type { IntrospectedAlias } from "../gir/alias.ts";
+import type { IntrospectedCallback } from "../gir/callback.ts";
+import type { IntrospectedConstant } from "../gir/const.ts";
+import type { IntrospectedConstructor } from "../gir/constructor.ts";
+import type { IntrospectedDirectAllocationConstructor } from "../gir/direct-allocation-constructor.ts";
+import type { IntrospectedEnum } from "../gir/enum.ts";
+import type { GirEnumMember } from "../gir/enum-member.ts";
+import type { IntrospectedError } from "../gir/error.ts";
+import type { IntrospectedFunction } from "../gir/function.ts";
+import type {
+	IntrospectedClass,
+	IntrospectedClassCallback,
+	IntrospectedClassFunction,
+	IntrospectedInterface,
+	IntrospectedStaticClassFunction,
+	IntrospectedVirtualClassFunction,
+} from "../gir/introspected-classes.ts";
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import type { IntrospectedFunctionParameter } from "../gir/parameter.ts";
+import type { IntrospectedField, IntrospectedProperty } from "../gir/property.ts";
+import type { IntrospectedRecord } from "../gir/record.ts";
+import type { IntrospectedSignal, IntrospectedSignalType } from "../gir/signal.ts";
+import type { TypeExpression } from "../gir.ts";
+import type { OptionsGeneration } from "../types/options-generation.ts";
+
+// TODO: Move to types/
+export interface GenericDescriptor {
+	type: TypeExpression;
+	name: string;
+}
+
+export abstract class FormatGenerator<T = string> {
+	protected namespace: IntrospectedNamespace;
+	protected options: OptionsGeneration;
+
+	constructor(namespace: IntrospectedNamespace, options: OptionsGeneration) {
+		this.namespace = namespace;
+		this.options = options;
+	}
+
+	abstract generateNamespace(node: IntrospectedNamespace): Promise<T | null>;
+	abstract stringifyNamespace(node: IntrospectedNamespace): Promise<string | null>;
+
+	abstract generateCallback(node: IntrospectedCallback): T;
+	abstract generateClassCallback(node: IntrospectedClassCallback): T;
+	abstract generateAlias(node: IntrospectedAlias): T;
+	abstract generateConstructor(node: IntrospectedConstructor): T;
+	abstract generateDirectAllocationConstructor(node: IntrospectedDirectAllocationConstructor): T;
+	abstract generateConstructorFunction(node: IntrospectedConstructor): T;
+	abstract generateRecord(node: IntrospectedRecord): T;
+	abstract generateInterface(node: IntrospectedInterface): T;
+	abstract generateEnumMember(node: GirEnumMember): T;
+	abstract generateError(node: IntrospectedError): T;
+	abstract generateEnum(node: IntrospectedEnum): T;
+	abstract generateConst(node: IntrospectedConstant): T;
+	abstract generateClass(node: IntrospectedClass): T;
+	abstract generateParameter(node: IntrospectedFunctionParameter): T;
+	abstract generateProperty(node: IntrospectedProperty, construct?: boolean): T;
+	abstract generateField(node: IntrospectedField): T;
+	abstract generateSignal(node: IntrospectedSignal, type?: IntrospectedSignalType): T;
+	abstract generateFunction(node: IntrospectedFunction): T;
+	abstract generateClassFunction(node: IntrospectedClassFunction): T;
+	abstract generateStaticClassFunction(node: IntrospectedStaticClassFunction): T;
+	abstract generateVirtualClassFunction(node: IntrospectedVirtualClassFunction): T;
+}

package/src/generators/index.ts

@@ -0,0 +1,2 @@
+// Common generator interfaces and utilities
+export * from "./generator.ts";

package/src/generics/clutter.ts

@@ -0,0 +1,71 @@
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import { GenericType } from "../gir.ts";
+import type { ClutterTemplateConfig } from "../types/generics-config.ts";
+
+function createClutterTemplate(version: string): ClutterTemplateConfig {
+	return {
+		namespace: "Clutter",
+		version,
+		modifier: (namespace: IntrospectedNamespace, inferGenerics: boolean) => {
+			if (!inferGenerics) {
+				return;
+			}
+
+			applyClutterGenerics(namespace);
+		},
+	};
+}
+
+function applyClutterGenerics(namespace: IntrospectedNamespace): void {
+	const Actor = namespace.assertClass("Actor");
+	const Content = namespace.assertClass("Content");
+	const LayoutManager = namespace.assertClass("LayoutManager");
+
+	// Add generics to Actor
+	Actor.addGeneric({
+		default: LayoutManager.getType(),
+		constraint: LayoutManager.getType(),
+	});
+
+	Actor.addGeneric({
+		default: Content.getType(),
+		constraint: Content.getType(),
+	});
+
+	// Update layout_manager properties
+	updatePropertyType(Actor, ["layout_manager", "layoutManager"], new GenericType("A", Content.getType()));
+
+	// Update content properties
+	updatePropertyType(Actor, ["content"], new GenericType("B", Content.getType()));
+
+	// Configure Clone class
+	const Clone = namespace.assertClass("Clone");
+	Clone.addGeneric({
+		default: Actor.getType(),
+		constraint: Actor.getType(),
+	});
+
+	updatePropertyType(Clone, ["source"], new GenericType("A", Content.getType()));
+}
+
+function updatePropertyType(
+	cls: ReturnType<IntrospectedNamespace["assertClass"]>,
+	propertyNames: string[],
+	newType: GenericType,
+): void {
+	cls.props
+		.filter((p) => propertyNames.includes(p.name))
+		.forEach((prop) => {
+			// TODO: Automatically infer such changes.
+			prop.type = newType;
+		});
+}
+
+// Version exports
+export const clutter10 = createClutterTemplate("10");
+export const clutter11 = createClutterTemplate("11");
+export const clutter12 = createClutterTemplate("12");
+export const clutter13 = createClutterTemplate("13");
+export const clutter14 = createClutterTemplate("14");
+export const clutter15 = createClutterTemplate("15");
+export const clutter16 = createClutterTemplate("16");

package/src/generics/generify.ts

@@ -0,0 +1,74 @@
+import type { NSRegistry } from "../gir/registry.ts";
+import type { NamespaceDefinition } from "../types/generics-config.ts";
+import { clutter10, clutter11, clutter12, clutter13, clutter14, clutter15 } from "./clutter.ts";
+import gio from "./gio.ts";
+import glib from "./glib.ts";
+import gtk from "./gtk.ts";
+import { meta10, meta11, meta12, meta13, meta14, meta15 } from "./meta.ts";
+import { st1, st12, st13, st14, st15 } from "./st.ts";
+import { GenericVisitor } from "./visitor.ts";
+
+// Core namespace definitions that are required
+const CORE_DEFINITIONS: NamespaceDefinition[] = [gio, glib];
+
+// Optional namespace definitions
+const OPTIONAL_DEFINITIONS: NamespaceDefinition[] = [
+	gtk,
+	clutter10,
+	clutter11,
+	clutter12,
+	clutter13,
+	clutter14,
+	clutter15,
+	st1,
+	st12,
+	st13,
+	st14,
+	st15,
+	meta10,
+	meta11,
+	meta12,
+	meta13,
+	meta14,
+	meta15,
+];
+
+function createDefinitionProcessor(registry: NSRegistry, inferGenerics: boolean, required: boolean = true) {
+	return (definition: NamespaceDefinition) => {
+		const { namespace: namespaceName, version, modifier } = definition;
+		const namespace = registry.namespace(namespaceName, version);
+
+		if (namespace) {
+			modifier(namespace, inferGenerics);
+			return;
+		}
+
+		if (required) {
+			throw new Error(`Could not generify ${namespaceName} ${version}`);
+		}
+	};
+}
+
+function applyDefinitions(
+	definitions: NamespaceDefinition[],
+	processor: (definition: NamespaceDefinition) => void,
+): void {
+	for (const definition of definitions) {
+		processor(definition);
+	}
+}
+
+export function generify(registry: NSRegistry, inferGenerics: boolean): void {
+	const processCoreDefinition = createDefinitionProcessor(registry, inferGenerics, true);
+	const processOptionalDefinition = createDefinitionProcessor(registry, inferGenerics, false);
+
+	// Apply core definitions (required)
+	applyDefinitions(CORE_DEFINITIONS, processCoreDefinition);
+
+	// Apply optional definitions
+	applyDefinitions(OPTIONAL_DEFINITIONS, processOptionalDefinition);
+
+	// Register visitor for runtime transformations
+	const visitor = new GenericVisitor(inferGenerics);
+	registry.registerTransformation(visitor);
+}

package/src/generics/gio.ts

@@ -0,0 +1,91 @@
+import type { IntrospectedBaseClass, IntrospectedClassFunction } from "../gir/introspected-classes.ts";
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import { AnyType, Generic, GenericType, GenerifiedTypeIdentifier, StringType, TypeIdentifier } from "../gir.ts";
+import type { GioConfig } from "../types/generics-config.ts";
+
+function createGioConfig(): GioConfig {
+	return {
+		namespace: "Gio",
+		version: "2.0",
+		modifier: (namespace: IntrospectedNamespace) => {
+			applyGioGenerics(namespace);
+		},
+	};
+}
+
+function applyGioGenerics(namespace: IntrospectedNamespace): void {
+	const GObject = namespace.assertInstalledImport("GObject").assertClass("Object");
+
+	setupAsyncInitable(namespace, GObject);
+	setupListModel(namespace, GObject);
+	setupListStore(namespace, GObject);
+	setupSettingsValueMethods(namespace);
+}
+
+function setupAsyncInitable(namespace: IntrospectedNamespace, GObject: IntrospectedBaseClass): void {
+	const AsyncInitable = namespace.getClass("AsyncInitable");
+	if (!AsyncInitable) {
+		throw new Error("Gio.AsyncInitable not found.");
+	}
+
+	AsyncInitable.addGeneric({
+		constraint: GObject.getType(),
+		default: GObject.getType(),
+		propagate: false,
+	});
+}
+
+function setupListModel(namespace: IntrospectedNamespace, GObject: IntrospectedBaseClass): void {
+	const ListModel = namespace.getClass("ListModel");
+	if (!ListModel) {
+		throw new Error("Gio.ListModel not found.");
+	}
+
+	ListModel.addGeneric({
+		default: GObject.getType(),
+		constraint: GObject.getType(),
+	});
+}
+
+function setupListStore(namespace: IntrospectedNamespace, GObject: IntrospectedBaseClass): void {
+	const ListModel = namespace.getClass("ListModel");
+	const ListStore = namespace.getClass("ListStore");
+
+	if (!ListStore) {
+		throw new Error("Gio.ListStore not found.");
+	}
+
+	ListStore.addGeneric({
+		deriveFrom: ListModel?.getType(),
+		default: GObject.getType(),
+		constraint: GObject.getType(),
+	});
+}
+
+function setupSettingsValueMethods(namespace: IntrospectedNamespace): void {
+	const Settings = namespace.assertClass("Settings");
+	const methodNames = ["get_value", "get_default_value", "get_user_value"];
+
+	Settings.members = Settings.members.map((member) => {
+		if (!methodNames.includes(member.name)) {
+			return member;
+		}
+
+		return updateSettingsMethod(member);
+	});
+}
+
+function updateSettingsMethod(method: IntrospectedClassFunction): IntrospectedClassFunction {
+	method.generics.push(new Generic(new GenericType("T"), AnyType, undefined, StringType));
+
+	const returnType = method.return().deepUnwrap();
+	if (returnType instanceof TypeIdentifier && returnType.is("GLib", "Variant")) {
+		return method.copy({
+			returnType: method.return().rewrap(new GenerifiedTypeIdentifier("Variant", "GLib", [new GenericType("T")])),
+		});
+	}
+
+	return method;
+}
+
+export default createGioConfig();

package/src/generics/glib.ts

@@ -0,0 +1,31 @@
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import { AnyType, StringType } from "../gir.ts";
+import type { GlibConfig } from "../types/generics-config.ts";
+
+function createGlibConfig(): GlibConfig {
+	return {
+		namespace: "GLib",
+		version: "2.0",
+		modifier: (namespace: IntrospectedNamespace) => {
+			applyGlibGenerics(namespace);
+		},
+	};
+}
+
+function applyGlibGenerics(namespace: IntrospectedNamespace): void {
+	const HashTable = namespace.getClass("HashTable");
+
+	if (!HashTable) {
+		throw new Error("GLib.HashTable not found.");
+	}
+
+	HashTable.addGeneric({
+		default: StringType,
+	});
+
+	HashTable.addGeneric({
+		default: AnyType,
+	});
+}
+
+export default createGlibConfig();

package/src/generics/gtk.ts

@@ -0,0 +1,99 @@
+import type { IntrospectedBaseClass } from "../gir/introspected-classes.ts";
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import { Generic, GenericType, GenerifiedTypeIdentifier } from "../gir.ts";
+import type { GtkConfig } from "../types/generics-config.ts";
+
+function createGtkConfig(): GtkConfig {
+	return {
+		namespace: "Gtk",
+		version: "4.0",
+		modifier: (namespace: IntrospectedNamespace) => {
+			applyGtkGenerics(namespace);
+		},
+	};
+}
+
+function applyGtkGenerics(namespace: IntrospectedNamespace): void {
+	const classes = getGtkClasses(namespace);
+	const GObject = namespace.assertInstalledImport("GObject").assertClass("Object");
+
+	setupStringListGenerics(classes, GObject);
+	updateBindModelMethods(classes, GObject);
+}
+
+function getGtkClasses(namespace: IntrospectedNamespace) {
+	const requiredClasses = {
+		FlowBox: namespace.getClass("FlowBox"),
+		ListBox: namespace.getClass("ListBox"),
+		StringList: namespace.getClass("StringList"),
+		StringObject: namespace.getClass("StringObject"),
+	};
+
+	// Validate required classes exist
+	for (const [name, cls] of Object.entries(requiredClasses)) {
+		if (!cls) {
+			throw new Error(`Gtk.${name} not found.`);
+		}
+	}
+
+	return requiredClasses as Record<
+		keyof typeof requiredClasses,
+		NonNullable<(typeof requiredClasses)[keyof typeof requiredClasses]>
+	>;
+}
+
+function setupStringListGenerics(classes: ReturnType<typeof getGtkClasses>, GObject: IntrospectedBaseClass): void {
+	const { StringList, StringObject } = classes;
+
+	StringList.addGeneric({
+		default: StringObject.getType(),
+		constraint: GObject.getType(),
+	});
+}
+
+function updateBindModelMethods(classes: ReturnType<typeof getGtkClasses>, GObject: IntrospectedBaseClass): void {
+	const { FlowBox, ListBox } = classes;
+
+	const bindModelConfigs = [
+		{ cls: FlowBox, widgetFuncName: "FlowBoxCreateWidgetFunc" },
+		{ cls: ListBox, widgetFuncName: "ListBoxCreateWidgetFunc" },
+	];
+
+	for (const config of bindModelConfigs) {
+		updateBindModelMethod(config.cls, config.widgetFuncName, GObject);
+	}
+}
+
+function updateBindModelMethod(
+	cls: IntrospectedBaseClass,
+	widgetFuncName: string,
+	GObject: IntrospectedBaseClass,
+): void {
+	cls.members = cls.members.map((member) => {
+		if (member.name !== "bind_model") {
+			return member;
+		}
+
+		member.generics.push(new Generic(new GenericType("A"), GObject.getType(), undefined, GObject.getType()));
+
+		return member.copy({
+			parameters: member.parameters.map((param) => {
+				if (param.name === "model") {
+					return param.copy({
+						type: new GenerifiedTypeIdentifier("ListModel", "Gio", [new GenericType("A")]),
+					});
+				}
+
+				if (param.name === "create_widget_func") {
+					return param.copy({
+						type: new GenerifiedTypeIdentifier(widgetFuncName, "Gtk", [new GenericType("A")]),
+					});
+				}
+
+				return param;
+			}),
+		});
+	});
+}
+
+export default createGtkConfig();

package/src/generics/meta.ts

@@ -0,0 +1,41 @@
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import { GenerifiedTypeIdentifier } from "../gir.ts";
+import type { MetaTemplateConfig } from "../types/generics-config.ts";
+
+function createMetaTemplate(version: string): MetaTemplateConfig {
+	return {
+		namespace: "Meta",
+		version,
+		modifier: (namespace: IntrospectedNamespace, inferGenerics: boolean) => {
+			if (!inferGenerics) {
+				return;
+			}
+
+			applyMetaGenerics(namespace);
+		},
+	};
+}
+
+function applyMetaGenerics(namespace: IntrospectedNamespace): void {
+	// Connect BackgroundActor to BackgroundContent
+	const LayoutManager = namespace.assertInstalledImport("Clutter").assertClass("LayoutManager");
+	const BackgroundContent = namespace.assertClass("BackgroundContent");
+	const BackgroundActor = namespace.assertClass("BackgroundActor");
+
+	const parent = BackgroundActor.superType;
+	if (parent) {
+		BackgroundActor.superType = new GenerifiedTypeIdentifier(parent.name, parent.namespace, [
+			LayoutManager.getType(),
+			BackgroundContent.getType(),
+		]);
+	}
+}
+
+// Version exports
+export const meta10 = createMetaTemplate("10");
+export const meta11 = createMetaTemplate("11");
+export const meta12 = createMetaTemplate("12");
+export const meta13 = createMetaTemplate("13");
+export const meta14 = createMetaTemplate("14");
+export const meta15 = createMetaTemplate("15");
+export const meta16 = createMetaTemplate("16");

package/src/generics/st.ts

@@ -0,0 +1,197 @@
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import { GenericType, GenerifiedTypeIdentifier } from "../gir.ts";
+import type { StTemplateConfig } from "../types/generics-config.ts";
+
+function createStTemplate(version: string): StTemplateConfig {
+	return {
+		namespace: "St",
+		version,
+		modifier: (namespace: IntrospectedNamespace, inferGenerics: boolean) => {
+			if (!inferGenerics) {
+				return;
+			}
+
+			applyStGenerics(namespace, version);
+		},
+	};
+}
+
+function applyStGenerics(namespace: IntrospectedNamespace, version: string): void {
+	const clutterImport = namespace.assertInstalledImport("Clutter");
+	const classes = getStClasses(namespace);
+	const clutterClasses = getClutterClasses(clutterImport, version);
+
+	setupWidgetGenerics(classes, clutterClasses);
+	setupViewportGenerics(classes, clutterClasses);
+	setupContainerGenerics(classes, clutterClasses, version);
+	setupBoxLayout(classes, clutterClasses);
+	setupBinGenerics(classes, clutterClasses);
+	setupScrollViewMethods(classes);
+}
+
+function getStClasses(namespace: IntrospectedNamespace) {
+	return {
+		Bin: namespace.assertClass("Bin"),
+		Button: namespace.assertClass("Button"),
+		ScrollView: namespace.assertClass("ScrollView"),
+		ScrollBar: namespace.assertClass("ScrollBar"),
+		Widget: namespace.assertClass("Widget"),
+		Viewport: namespace.assertClass("Viewport"),
+		StBoxLayout: namespace.assertClass("BoxLayout"),
+	};
+}
+
+function getClutterClasses(clutterImport: ReturnType<IntrospectedNamespace["assertInstalledImport"]>, version: string) {
+	return {
+		Actor: clutterImport.assertClass("Actor"),
+		Content: clutterImport.assertClass("Content"),
+		Container: Number(version) < 14 ? clutterImport.assertClass("Container") : null,
+		LayoutManager: clutterImport.assertClass("LayoutManager"),
+		ClutterBoxLayout: clutterImport.assertClass("BoxLayout"),
+	};
+}
+
+function setupWidgetGenerics(
+	stClasses: ReturnType<typeof getStClasses>,
+	clutterClasses: ReturnType<typeof getClutterClasses>,
+): void {
+	const { Widget } = stClasses;
+	const { Actor, Content, LayoutManager } = clutterClasses;
+
+	Widget.addGeneric({
+		deriveFrom: Actor.getType(),
+		default: LayoutManager.getType(),
+		constraint: LayoutManager.getType(),
+	});
+
+	Widget.addGeneric({
+		deriveFrom: Actor.getType(),
+		default: Content.getType(),
+		constraint: Content.getType(),
+	});
+}
+
+function setupViewportGenerics(
+	stClasses: ReturnType<typeof getStClasses>,
+	clutterClasses: ReturnType<typeof getClutterClasses>,
+): void {
+	const { Viewport, Widget } = stClasses;
+	const { Content, LayoutManager } = clutterClasses;
+
+	Viewport.addGeneric({
+		deriveFrom: Widget.getType(),
+		default: LayoutManager.getType(),
+		constraint: LayoutManager.getType(),
+	});
+
+	Viewport.addGeneric({
+		deriveFrom: Widget.getType(),
+		default: Content.getType(),
+		constraint: Content.getType(),
+	});
+}
+
+function setupContainerGenerics(
+	stClasses: ReturnType<typeof getStClasses>,
+	clutterClasses: ReturnType<typeof getClutterClasses>,
+	_version: string,
+): void {
+	const { StBoxLayout } = stClasses;
+	const { Actor, Container } = clutterClasses;
+
+	if (!Container) {
+		return;
+	}
+
+	Container.addGeneric({
+		default: Actor.getType(),
+		constraint: Actor.getType(),
+	});
+
+	StBoxLayout.addGeneric({
+		deriveFrom: Container.getType(),
+		default: Actor.getType(),
+		constraint: Actor.getType(),
+	});
+}
+
+function setupBoxLayout(
+	stClasses: ReturnType<typeof getStClasses>,
+	clutterClasses: ReturnType<typeof getClutterClasses>,
+): void {
+	const { StBoxLayout } = stClasses;
+	const { ClutterBoxLayout } = clutterClasses;
+
+	if (StBoxLayout.superType) {
+		StBoxLayout.superType = new GenerifiedTypeIdentifier(StBoxLayout.superType.name, StBoxLayout.superType.namespace, [
+			ClutterBoxLayout.getType(),
+		]);
+	}
+}
+
+function setupBinGenerics(
+	stClasses: ReturnType<typeof getStClasses>,
+	clutterClasses: ReturnType<typeof getClutterClasses>,
+): void {
+	const { Bin, Button, ScrollView } = stClasses;
+	const { Actor } = clutterClasses;
+
+	Bin.addGeneric({
+		default: Actor.getType(),
+		constraint: Actor.getType(),
+	});
+
+	Button.addGeneric({
+		deriveFrom: Bin.getType(),
+		default: Actor.getType(),
+		constraint: Actor.getType(),
+	});
+
+	ScrollView.addGeneric({
+		deriveFrom: Bin.getType(),
+		default: Actor.getType(),
+		constraint: Actor.getType(),
+	});
+
+	// Update Bin child property
+	updatePropertyType(Bin, ["child"], new GenericType("A", Actor.getType()));
+}
+
+function setupScrollViewMethods(stClasses: ReturnType<typeof getStClasses>): void {
+	const { ScrollView, ScrollBar } = stClasses;
+
+	const methodConfigs = [
+		{ name: "get_hscroll_bar", returnType: ScrollBar.getType() },
+		{ name: "get_vscroll_bar", returnType: ScrollBar.getType() },
+	];
+
+	for (const config of methodConfigs) {
+		const method = ScrollView.members.find((member) => member.name === config.name);
+		if (method) {
+			const fixedMethod = method.copy({ returnType: config.returnType });
+			const index = ScrollView.members.indexOf(method);
+			ScrollView.members.splice(index, 1, fixedMethod);
+		}
+	}
+}
+
+function updatePropertyType(
+	cls: ReturnType<IntrospectedNamespace["assertClass"]>,
+	propertyNames: string[],
+	newType: GenericType,
+): void {
+	cls.props
+		.filter((p) => propertyNames.includes(p.name))
+		.forEach((prop) => {
+			// TODO: Automatically infer such changes.
+			prop.type = newType;
+		});
+}
+
+// Version exports
+export const st1 = createStTemplate("1.0");
+export const st12 = createStTemplate("12");
+export const st13 = createStTemplate("13");
+export const st14 = createStTemplate("14");
+export const st15 = createStTemplate("15");
+export const st16 = createStTemplate("16");