@ts-for-gir/lib 4.0.0-beta.9 → 4.0.0-rc.2

package/src/gir/error.ts

@@ -0,0 +1,89 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import type { GirBitfieldElement, GirEnumElement } from "../index.ts";
+import type { OptionsLoad } from "../types/index.ts";
+
+import { parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { sanitizeMemberName } from "../utils/naming.ts";
+import { IntrospectedEnum } from "./enum.ts";
+import { GirEnumMember } from "./enum-member.ts";
+import { IntrospectedStaticClassFunction } from "./introspected-classes.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+import type { IntrospectedRecord } from "./record.ts";
+
+// TODO: Move to utils
+function isEnumElement(e: unknown): e is GirEnumElement {
+	return typeof e === "object" && e != null && "function" in e;
+}
+
+export class IntrospectedError extends IntrospectedEnum {
+	functions: Map<string, IntrospectedStaticClassFunction> = new Map();
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateError"]> {
+		return generator.generateError(this) as ReturnType<T["generateError"]>;
+	}
+
+	copy({ members }: { parent?: undefined; members?: Map<string, GirEnumMember> } = {}): IntrospectedEnum {
+		const { namespace, name, flags } = this;
+
+		const en = new IntrospectedError(name, namespace);
+
+		for (const [key, member] of (members ?? this.members).entries()) {
+			en.members.set(key, member.copy());
+		}
+
+		for (const [key, func] of this.functions.entries()) {
+			en.functions.set(key, func.copy({ parent: en }));
+		}
+
+		en.flags = flags;
+
+		return en._copyBaseProperties(this);
+	}
+
+	asClass(): IntrospectedRecord {
+		const clazz = super.asClass();
+		clazz.overrideGType(this.namespace.namespace === "GLib" ? "Error" : "GLib.Error");
+		return clazz;
+	}
+
+	static fromXML(
+		element: GirEnumElement | GirBitfieldElement,
+		ns: IntrospectedNamespace,
+		options: OptionsLoad,
+	): IntrospectedEnum {
+		const err = new IntrospectedError(sanitizeMemberName(element.$.name), ns);
+
+		if (element.$["glib:type-name"]) {
+			err.resolve_names.push(element.$["glib:type-name"]);
+
+			ns.registerResolveName(element.$["glib:type-name"], ns.namespace, err.name);
+		}
+
+		if (element.$["c:type"]) {
+			err.resolve_names.push(element.$["c:type"]);
+
+			ns.registerResolveName(element.$["c:type"], ns.namespace, err.name);
+		}
+
+		if (options.loadDocs) {
+			err.doc = parseDoc(element);
+			err.metadata = parseMetadata(element);
+		}
+
+		if (element.member) {
+			element.member.forEach((m) => {
+				const member = GirEnumMember.fromXML(m, err, options);
+				err.members.set(member.name, member);
+			});
+		}
+
+		if (isEnumElement(element) && element.function) {
+			element.function.forEach((f) => {
+				const func = IntrospectedStaticClassFunction.fromXML(f, err, options);
+				err.functions.set(func.name, func);
+			});
+		}
+
+		return err;
+	}
+}

package/src/gir/function.ts

@@ -0,0 +1,296 @@
+import { GirDirection } from "@gi.ts/parser";
+import type { FormatGenerator } from "../generators/generator.ts";
+import {
+	ArrayType,
+	ClosureType,
+	type Generic,
+	NullableType,
+	type TypeExpression,
+	TypeIdentifier,
+	UnknownType,
+	VoidType,
+} from "../gir.ts";
+
+import type { GirFunctionElement, GirMethodElement, GirModule } from "../index.ts";
+import type { IntrospectedOptions, OptionsLoad } from "../types/index.ts";
+import { getType, hasShadow, parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { isIntrospectable } from "../utils/girs.ts";
+import { sanitizeIdentifierName } from "../utils/naming.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedNamespaceMember } from "./introspected-namespace-member.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+
+import { IntrospectedFunctionParameter } from "./parameter.ts";
+
+export class IntrospectedFunction extends IntrospectedNamespaceMember {
+	readonly parameters: IntrospectedFunctionParameter[];
+	readonly output_parameters: IntrospectedFunctionParameter[];
+	readonly return_type: TypeExpression;
+	readonly raw_name: string;
+
+	generics: Generic[] = [];
+	returnTypeDoc: string | null;
+
+	constructor({
+		name,
+		raw_name,
+		return_type = UnknownType,
+		parameters = [],
+		output_parameters = [],
+		namespace,
+		...args
+	}: IntrospectedOptions<{
+		name: string;
+		raw_name: string;
+		return_type?: TypeExpression;
+		parameters?: IntrospectedFunctionParameter[];
+		output_parameters?: IntrospectedFunctionParameter[];
+		namespace: GirModule;
+	}>) {
+		super(name, namespace, { ...args });
+
+		this.raw_name = raw_name;
+		this.parameters = parameters.map((p) => p.copy({ parent: this }));
+		this.output_parameters = output_parameters.map((p) => p.copy({ parent: this }));
+		this.return_type = return_type;
+		this.returnTypeDoc = null;
+	}
+
+	copy(
+		{
+			parent = this.parent,
+			outputParameters,
+			parameters,
+			return_type,
+		}: {
+			parent?: GirModule;
+			parameters?: IntrospectedFunctionParameter[];
+			outputParameters?: IntrospectedFunctionParameter[];
+			return_type?: TypeExpression;
+		} = { parent: this.parent },
+	): IntrospectedFunction {
+		const fn = new IntrospectedFunction({
+			namespace: parent ?? this.namespace,
+			raw_name: this.raw_name,
+			name: this.name,
+			return_type: return_type ?? this.return_type,
+			output_parameters: outputParameters ?? this.output_parameters,
+			parameters: parameters ?? this.parameters,
+		});
+
+		fn.returnTypeDoc = this.returnTypeDoc;
+		fn.generics = [...this.generics];
+
+		return fn._copyBaseProperties(this);
+	}
+
+	accept(visitor: GirVisitor): IntrospectedFunction {
+		const node = this.copy({
+			parent: this.parent,
+			parameters: this.parameters.map((p) => {
+				return p.accept(visitor);
+			}),
+			outputParameters: this.output_parameters.map((p) => {
+				return p.accept(visitor);
+			}),
+			return_type: visitor.visitType?.(this.return_type),
+		});
+
+		return visitor.visitFunction?.(node) ?? node;
+	}
+
+	static fromXML(
+		element: GirFunctionElement | GirMethodElement,
+		ns: IntrospectedNamespace,
+		options: OptionsLoad,
+	): IntrospectedFunction {
+		let raw_name = element.$.name;
+		let name = sanitizeIdentifierName(null, raw_name);
+
+		if (hasShadow(element)) {
+			raw_name = element.$.shadows;
+			name = sanitizeIdentifierName(null, element.$.shadows);
+		}
+
+		const return_type = IntrospectedFunction.parseReturnType(element, ns);
+		const { input_parameters, output_parameters, returnTypeDoc } = IntrospectedFunction.parseParameters(
+			element,
+			ns,
+			return_type,
+			options,
+		);
+
+		const fn = new IntrospectedFunction({
+			name,
+			raw_name,
+			namespace: ns,
+			parameters: input_parameters,
+			output_parameters,
+			return_type,
+			isIntrospectable: isIntrospectable(element),
+		});
+
+		fn.returnTypeDoc = returnTypeDoc;
+
+		if (options.loadDocs) {
+			fn.doc = parseDoc(element);
+			fn.metadata = parseMetadata(element);
+		}
+
+		return fn;
+	}
+
+	private static parseReturnType(
+		element: GirFunctionElement | GirMethodElement,
+		ns: IntrospectedNamespace,
+	): TypeExpression {
+		if ("return-value" in element && element["return-value"] && element["return-value"].length > 0) {
+			const value = element["return-value"][0];
+			return getType(ns, value);
+		}
+		return VoidType;
+	}
+
+	private static parseParameters(
+		element: GirFunctionElement | GirMethodElement,
+		ns: IntrospectedNamespace,
+		return_type: TypeExpression,
+		options: OptionsLoad,
+	): {
+		input_parameters: IntrospectedFunctionParameter[];
+		output_parameters: IntrospectedFunctionParameter[];
+		returnTypeDoc: string | null;
+	} {
+		let returnTypeDoc: string | null = null;
+
+		if ("return-value" in element && element["return-value"] && element["return-value"].length > 0) {
+			const value = element["return-value"][0];
+			returnTypeDoc = parseDoc(value);
+		}
+
+		if (!element.parameters) {
+			return { input_parameters: [], output_parameters: [], returnTypeDoc };
+		}
+
+		const param = element.parameters[0].parameter;
+		if (!param) {
+			return { input_parameters: [], output_parameters: [], returnTypeDoc };
+		}
+
+		// Create a temporary function for parameter processing
+		const tempFn = new IntrospectedFunction({
+			name: "temp",
+			raw_name: "temp",
+			namespace: ns,
+			isIntrospectable: isIntrospectable(element),
+		});
+
+		const inputs = param.filter((p): p is typeof p & { $: { name: string } } => !!p.$.name);
+		let parameters = inputs.map((i) => IntrospectedFunctionParameter.fromXML(i, tempFn, options));
+
+		const unwrapped = return_type.unwrap();
+		const length_params = unwrapped instanceof ArrayType && unwrapped.length != null ? [unwrapped.length] : [];
+		const user_data_params: number[] = [];
+
+		parameters = IntrospectedFunction.processParameterTypes(parameters, length_params, user_data_params);
+		parameters = IntrospectedFunction.filterParameters(parameters, length_params, user_data_params);
+		parameters = IntrospectedFunction.processOptionalParameters(parameters);
+
+		const input_parameters = parameters.filter(
+			(param) => param.direction === GirDirection.In || param.direction === GirDirection.Inout,
+		);
+		const output_parameters = parameters
+			.filter(
+				(param) => param.direction && (param.direction === GirDirection.Out || param.direction === GirDirection.Inout),
+			)
+			.map((parameter) => parameter.copy({ isOptional: false }));
+
+		return { input_parameters, output_parameters, returnTypeDoc };
+	}
+
+	private static processParameterTypes(
+		parameters: IntrospectedFunctionParameter[],
+		length_params: number[],
+		user_data_params: number[],
+	): IntrospectedFunctionParameter[] {
+		return parameters.map((p) => {
+			const unwrapped_type = p.type.unwrap();
+
+			if (unwrapped_type instanceof ArrayType && unwrapped_type.length != null) {
+				length_params.push(unwrapped_type.length);
+			}
+
+			if (unwrapped_type instanceof ClosureType && unwrapped_type.user_data != null) {
+				user_data_params.push(unwrapped_type.user_data);
+			}
+
+			return p;
+		});
+	}
+
+	private static filterParameters(
+		parameters: IntrospectedFunctionParameter[],
+		length_params: number[],
+		user_data_params: number[],
+	): IntrospectedFunctionParameter[] {
+		return parameters
+			.filter((_, i) => !length_params.includes(i) && !user_data_params.includes(i))
+			.filter((v) => !(v.type instanceof TypeIdentifier && v.type.is("GLib", "DestroyNotify")));
+	}
+
+	private static processOptionalParameters(
+		parameters: IntrospectedFunctionParameter[],
+	): IntrospectedFunctionParameter[] {
+		return parameters
+			.reverse()
+			.reduce(
+				({ allowOptions, params }, p) => {
+					const { type, isOptional } = p;
+
+					if (allowOptions) {
+						if (type instanceof NullableType) {
+							params.push(p.copy({ isOptional: true }));
+						} else if (!isOptional) {
+							params.push(p);
+							return { allowOptions: false, params };
+						} else {
+							params.push(p);
+						}
+					} else {
+						if (isOptional) {
+							params.push(p.copy({ type: new NullableType(type), isOptional: false }));
+						} else {
+							params.push(p);
+						}
+					}
+
+					return { allowOptions, params };
+				},
+				{
+					allowOptions: true,
+					params: [] as IntrospectedFunctionParameter[],
+				},
+			)
+			.params.reverse()
+			.filter((p): p is IntrospectedFunctionParameter => p != null);
+	}
+
+	return() {
+		return this.return_type;
+	}
+
+	getCallbackParameters() {
+		return {
+			name: this.name,
+			raw_name: this.raw_name,
+			namespace: this.namespace,
+			output_parameters: this.output_parameters,
+			parameters: this.parameters,
+			return_type: this.return_type,
+		};
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateFunction"]> {
+		return generator.generateFunction(this) as ReturnType<T["generateFunction"]>;
+	}
+}

package/src/gir/generics.ts

@@ -0,0 +1,66 @@
+const GenericNames = [
+	"A",
+	"B",
+	"C",
+	"D",
+	"E",
+	"F",
+	"G",
+	"H",
+	"I",
+	"J",
+	"K",
+	"L",
+	"M",
+	"N",
+	"O",
+	"P",
+	"Q",
+	"R",
+	"S",
+	"U",
+	"V",
+	"W",
+	"X",
+	"Y",
+	"Z",
+];
+
+export function* getGenericNames(start: string = "A") {
+	let names = GenericNames.map((s) => `${s}`);
+	const startIteration = Number.parseInt(start.slice(1) || "0", 10);
+
+	let i = startIteration;
+
+	names = names.map((s) => (i === 0 ? s : `${s}${i}`));
+
+	const StartLetter = start[0];
+	const position = GenericNames.indexOf(StartLetter);
+
+	while (true) {
+		for (const name of names) {
+			if (i === startIteration && GenericNames.indexOf(name) >= position) {
+				yield name;
+			}
+		}
+
+		names = names.map((s) => `${s}${i}`);
+
+		i++;
+	}
+
+	// This will always be a string return.
+	return "ThisShouldNeverHappen";
+}
+
+export function createGenericNameGenerator(): () => string {
+	const genericNames = getGenericNames();
+
+	return () => genericNames.next().value;
+}
+
+export function createGenericNameGeneratorAt(start: string): () => string {
+	const genericNames = getGenericNames(start);
+
+	return () => genericNames.next().value;
+}

package/src/gir/gir-complex-record.ts

@@ -0,0 +1,7 @@
+import { IntrospectedRecord } from "./record.ts";
+
+export class GirComplexRecord extends IntrospectedRecord {
+	isSimple() {
+		return false;
+	}
+}

package/src/gir/index.ts

@@ -0,0 +1,25 @@
+export * from "./alias.ts";
+export * from "./callback.ts";
+
+export * from "./const.ts";
+export * from "./constructor.ts";
+export * from "./data.ts";
+export * from "./direct-allocation-constructor.ts";
+export * from "./enum.ts";
+export * from "./enum-member.ts";
+export * from "./error.ts";
+export * from "./function.ts";
+export * from "./generics.ts";
+export * from "./gir-complex-record.ts";
+export * from "./introspected-base.ts";
+export * from "./introspected-class-member.ts";
+export * from "./introspected-classes.ts";
+export * from "./introspected-namespace-member.ts";
+export * from "./namespace.ts";
+
+export * from "./parameter.ts";
+export * from "./promisify.ts";
+export * from "./property.ts";
+export * from "./record.ts";
+export * from "./registry.ts";
+export * from "./signal.ts";

package/src/gir/introspected-base.ts

@@ -0,0 +1,104 @@
+import type { FormatGenerator } from "../generators/index.ts";
+import type {
+	AnyIntrospectedType,
+	GirMemberElement,
+	IntrospectedBaseOptions,
+	IntrospectedMetadata,
+	OptionsLoad,
+} from "../types/index.ts";
+import type { GirVisitor } from "../visitor.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+
+export abstract class IntrospectedBase<Parent extends IntrospectedNamespace | AnyIntrospectedType | null> {
+	name: string;
+	doc?: string | null;
+	metadata?: IntrospectedMetadata;
+	deprecated?: boolean;
+	resolve_names: string[] = [];
+	private _emit = true;
+	private _commentWarning?: string;
+	private _isPrivate: boolean;
+	private _isIntrospectable: boolean;
+	private _parent: Parent;
+
+	constructor(name: string, parent: Parent, options: IntrospectedBaseOptions = {}) {
+		this.name = name;
+		this._parent = parent;
+		this._isPrivate = options.isPrivate ?? false;
+		this._isIntrospectable = options.isIntrospectable ?? true;
+		this.doc = options.doc ?? null;
+	}
+
+	get parent(): Parent {
+		return this._parent;
+	}
+
+	/**
+	 * Set a warning to be emitted with this node. Often used to note type
+	 * conflicts or potential differences from GJS code.
+	 *
+	 * @param warning
+	 */
+	setWarning(warning: string) {
+		this._commentWarning = warning;
+	}
+
+	getWarning(): string | undefined {
+		return this._commentWarning;
+	}
+
+	abstract get namespace(): IntrospectedNamespace;
+
+	get isIntrospectable() {
+		return this._isIntrospectable;
+	}
+
+	get isPrivate() {
+		return this._isPrivate;
+	}
+
+	setPrivate(priv: boolean) {
+		this._isPrivate = priv;
+	}
+
+	noEmit() {
+		this._emit = false;
+	}
+
+	get emit() {
+		return this._emit;
+	}
+
+	protected _copyBaseProperties(from: this): this {
+		this.doc = from.doc;
+		this.metadata = from.metadata;
+		this.deprecated = from.deprecated;
+		this.resolve_names = from.resolve_names;
+
+		// Whether this node should be emitted.
+		this._emit = from._emit;
+		this._isPrivate = from._isPrivate;
+		this._isIntrospectable = from.isIntrospectable;
+
+		return this;
+	}
+
+	abstract copy(options?: { parent?: Parent }): IntrospectedBase<Parent>;
+
+	abstract accept(visitor: GirVisitor): IntrospectedBase<Parent>;
+
+	static fromXML(
+		_element: GirMemberElement,
+
+		_parent: IntrospectedNamespace | AnyIntrospectedType,
+
+		_options: OptionsLoad,
+	): AnyIntrospectedType | null {
+		throw new Error("GirBase cannot be instantiated");
+	}
+
+	abstract asString<T extends FormatGenerator<unknown>>(
+		generator: T,
+	): (T extends FormatGenerator<infer R> ? R : never) | null;
+	abstract asString<T extends FormatGenerator<unknown>>(generator: T): unknown;
+}

package/src/gir/introspected-class-member.ts

@@ -0,0 +1,15 @@
+import { IntrospectedBase } from "./introspected-base.ts";
+
+import type { IntrospectedBaseClass } from "./introspected-classes.ts";
+
+export abstract class IntrospectedClassMember<
+	Parent extends IntrospectedBaseClass | null = IntrospectedBaseClass | null,
+> extends IntrospectedBase<Parent> {
+	get namespace() {
+		if (!this.parent) {
+			throw new Error(`Failed to get namespace for ${this.name}`);
+		}
+
+		return this.parent.namespace;
+	}
+}