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

package/src/generics/visitor.ts

@@ -0,0 +1,484 @@
+import type { IntrospectedCallback } from "../gir/callback.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 { IntrospectedFunction } from "../gir/function.ts";
+import { createGenericNameGenerator } from "../gir/generics.ts";
+import type { IntrospectedInterface, IntrospectedVirtualClassFunction } from "../gir/introspected-classes.ts";
+import {
+	IntrospectedBaseClass,
+	IntrospectedClass,
+	IntrospectedClassFunction,
+	IntrospectedStaticClassFunction,
+} from "../gir/introspected-classes.ts";
+import type { IntrospectedFunctionParameter } from "../gir/parameter.ts";
+import type { IntrospectedSignal } from "../gir/signal.ts";
+import {
+	ClosureType,
+	Generic,
+	GenericType,
+	GenerifiedTypeIdentifier,
+	ThisType,
+	type TypeExpression,
+	TypeIdentifier,
+} from "../gir.ts";
+import { resolveTypeIdentifier } from "../utils/type-resolution.ts";
+import { GirVisitor } from "../visitor.ts";
+
+/**
+ * Visitor that handles generic type inference and transformations
+ */
+export class GenericVisitor extends GirVisitor {
+	private readonly inferGenerics: boolean;
+
+	constructor(inferGenerics: boolean) {
+		super();
+		this.inferGenerics = inferGenerics;
+	}
+
+	visitCallback = (node: IntrospectedCallback): IntrospectedCallback => {
+		if (!this.inferGenerics) {
+			return node;
+		}
+
+		const shouldGenerify = this.shouldGenerifyCallback(node);
+		if (!shouldGenerify) {
+			return node;
+		}
+
+		return this.createGenerifiedCallback(node);
+	};
+
+	visitClass = (node: IntrospectedClass): IntrospectedClass => {
+		return this.visitBaseClass(node);
+	};
+
+	visitInterface = (node: IntrospectedInterface): IntrospectedInterface => {
+		return this.visitBaseClass(node);
+	};
+
+	visitParameter = (node: IntrospectedFunctionParameter): IntrospectedFunctionParameter => {
+		if (!this.inferGenerics) {
+			return node;
+		}
+
+		const unwrapped = node.type.unwrap();
+		if (!(unwrapped instanceof ClosureType)) {
+			return node;
+		}
+
+		return this.processAsyncReadyCallback(node) ?? node;
+	};
+
+	visitFunction = (node: IntrospectedFunction): IntrospectedFunction => {
+		if (!this.inferGenerics) {
+			return node;
+		}
+
+		const unwrapped = node.return_type.unwrap();
+		const shouldGenerify = unwrapped instanceof TypeIdentifier && unwrapped.is("GObject", "Object");
+
+		if (!shouldGenerify) {
+			return node;
+		}
+
+		return this.createGenerifiedFunction(node, unwrapped);
+	};
+
+	visitStaticClassFunction = (node: IntrospectedStaticClassFunction): IntrospectedStaticClassFunction => {
+		if (this.inferGenerics) {
+			return this.generifyStandaloneClassFunction(node);
+		}
+		return node;
+	};
+
+	visitClassFunction = <T extends IntrospectedBaseClass | IntrospectedEnum>(
+		node: IntrospectedClassFunction<T>,
+	): IntrospectedClassFunction<T> => {
+		if (node.parent instanceof IntrospectedBaseClass) {
+			const processedNode = this.processClassFunctionWithGenerics(node);
+			if (processedNode) {
+				return processedNode;
+			}
+		}
+
+		if (this.inferGenerics) {
+			return this.generifyStandaloneClassFunction(node);
+		}
+
+		return node;
+	};
+
+	visitVirtualClassFunction = (node: IntrospectedVirtualClassFunction): IntrospectedVirtualClassFunction => {
+		return this.visitClassFunction(node);
+	};
+
+	// Private helper methods
+
+	private visitBaseClass<T extends IntrospectedBaseClass>(node: T): T {
+		const copiedNode = node.copy() as T;
+		const derivatives = copiedNode.generics.filter((generic) => generic.parent != null);
+
+		this.processInterfaces(copiedNode, derivatives);
+		this.processSuperType(copiedNode, derivatives);
+
+		return copiedNode;
+	}
+
+	private shouldGenerifyCallback(node: IntrospectedCallback): boolean {
+		return node.parameters.some((parameter) => this.isGObjectType(parameter.type.unwrap()));
+	}
+
+	private isGObjectType(type: TypeExpression): boolean {
+		return type instanceof TypeIdentifier && type.is("GObject", "Object");
+	}
+
+	private createGenerifiedCallback(node: IntrospectedCallback): IntrospectedCallback {
+		const generateName = createGenericNameGenerator();
+		const generics: Generic[] = [];
+
+		const generifiedParameters = node.parameters.map((parameter) => {
+			const type = parameter.type.unwrap();
+
+			if (this.isGObjectType(type)) {
+				const { identifier, generic } = this.createGeneric(generateName(), type as TypeIdentifier);
+				generics.push(generic);
+
+				return parameter.copy({
+					type: parameter.type.rewrap(identifier),
+				});
+			}
+
+			return parameter;
+		});
+
+		const generifiedCallback = node.copy({
+			parameters: generifiedParameters,
+		});
+
+		generifiedCallback.generics = generics;
+		return generifiedCallback;
+	}
+
+	private createGeneric(identifier: string, baseType: TypeIdentifier): { identifier: GenericType; generic: Generic } {
+		const genericType = new GenericType(identifier, baseType);
+		const generic = new Generic(genericType, baseType);
+		return { identifier: genericType, generic };
+	}
+
+	private processInterfaces<T extends IntrospectedBaseClass>(node: T, derivatives: Generic[]): void {
+		if (!(node instanceof IntrospectedClass)) {
+			return;
+		}
+
+		const resolvedInterfaces = this.resolveInterfaces(node);
+		node.interfaces = node.interfaces.map((iface) =>
+			this.processInterface(node, iface, derivatives, resolvedInterfaces),
+		);
+	}
+
+	private resolveInterfaces(node: IntrospectedClass): IntrospectedBaseClass[] {
+		return node.interfaces
+			.map((i) => resolveTypeIdentifier(node.namespace, i))
+			.filter((c): c is IntrospectedBaseClass => c != null);
+	}
+
+	private processInterface<T extends IntrospectedBaseClass>(
+		node: T,
+		iface: TypeIdentifier,
+		derivatives: Generic[],
+		resolvedInterfaces: IntrospectedBaseClass[],
+	): TypeIdentifier {
+		const matchingGenerics = derivatives.filter((d) => d.parent?.is(iface.namespace, iface.name));
+
+		if (matchingGenerics.length > 0) {
+			return new GenerifiedTypeIdentifier(
+				iface.name,
+				iface.namespace,
+				matchingGenerics.map((g) => g.type),
+			);
+		}
+
+		const resolved = resolvedInterfaces.find((i) => i.getType().equals(iface));
+		if (resolved) {
+			return this.processResolvedInterface(node, iface, resolved);
+		}
+
+		return iface;
+	}
+
+	private processResolvedInterface<T extends IntrospectedBaseClass>(
+		node: T,
+		iface: TypeIdentifier,
+		resolved: IntrospectedBaseClass,
+	): TypeIdentifier {
+		if (resolved.generics.length !== 1) {
+			return iface;
+		}
+
+		const [generic] = resolved.generics;
+
+		if (generic.propagate) {
+			return this.handlePropagatingInterfaceGeneric(node, iface, resolved, generic);
+		}
+
+		return new GenerifiedTypeIdentifier(iface.name, iface.namespace, [node.getType()]);
+	}
+
+	private handlePropagatingInterfaceGeneric<T extends IntrospectedBaseClass>(
+		node: T,
+		iface: TypeIdentifier,
+		resolved: IntrospectedBaseClass,
+		generic: Generic,
+	): TypeIdentifier {
+		const constrainedGeneric = this.findConstrainedGeneric(node, generic);
+
+		if (constrainedGeneric) {
+			return new GenerifiedTypeIdentifier(iface.name, iface.namespace, [constrainedGeneric.type]);
+		}
+
+		if (this.shouldAddNewGeneric(node, generic)) {
+			this.addGenericToNode(node, resolved, generic);
+			const firstGeneric = node.generics[node.generics.length - 1];
+			return new GenerifiedTypeIdentifier(resolved.name, resolved.namespace.namespace, [firstGeneric.type]);
+		}
+
+		return new GenerifiedTypeIdentifier(iface.name, iface.namespace, [node.getType()]);
+	}
+
+	private findConstrainedGeneric<T extends IntrospectedBaseClass>(node: T, generic: Generic): Generic | undefined {
+		return node.generics.find((d) => generic.constraint && d.constraint?.equals(generic.constraint));
+	}
+
+	private shouldAddNewGeneric<T extends IntrospectedBaseClass>(node: T, generic: Generic): boolean {
+		return !generic.defaultType?.equals(node.getType()) && !generic.constraint?.equals(node.getType());
+	}
+
+	private addGenericToNode<T extends IntrospectedBaseClass>(
+		node: T,
+		resolved: IntrospectedBaseClass,
+		generic: Generic,
+	): void {
+		node.addGeneric({
+			constraint: generic.constraint ?? undefined,
+			default: generic.defaultType ?? undefined,
+			deriveFrom: resolved.getType(),
+		});
+	}
+
+	private processSuperType<T extends IntrospectedBaseClass>(node: T, derivatives: Generic[]): void {
+		if (!node.superType) {
+			return;
+		}
+
+		const parentType = node.superType;
+		const matchingGenerics = derivatives.filter((d) => d.parent?.is(parentType.namespace, parentType.name));
+
+		if (node.superType instanceof GenerifiedTypeIdentifier) {
+			return;
+		}
+
+		if (matchingGenerics.length > 0) {
+			node.superType = new GenerifiedTypeIdentifier(
+				parentType.name,
+				parentType.namespace,
+				matchingGenerics.map((g) => g.type),
+			);
+			return;
+		}
+
+		const resolvedParent = resolveTypeIdentifier(node.namespace, node.superType);
+		this.processResolvedParent(node, resolvedParent);
+	}
+
+	private processResolvedParent<T extends IntrospectedBaseClass>(
+		node: T,
+		resolved: IntrospectedBaseClass | null,
+	): void {
+		if (!resolved || resolved.generics.length !== 1) {
+			return;
+		}
+
+		const [generic] = resolved.generics;
+
+		if (generic.propagate) {
+			this.handlePropagatingGeneric(node, resolved, generic);
+		} else if (this.shouldUseNodeType(node, generic)) {
+			node.superType = new GenerifiedTypeIdentifier(resolved.name, resolved.namespace.namespace, [node.getType()]);
+		}
+	}
+
+	private handlePropagatingGeneric<T extends IntrospectedBaseClass>(
+		node: T,
+		resolved: IntrospectedBaseClass,
+		generic: Generic,
+	): void {
+		const constrainedGeneric = this.findConstrainedGeneric(node, generic);
+
+		if (constrainedGeneric) {
+			node.superType = new GenerifiedTypeIdentifier(resolved.name, resolved.namespace.namespace, [
+				constrainedGeneric.type,
+			]);
+			return;
+		}
+
+		if (this.shouldAddNewGeneric(node, generic)) {
+			this.addGenericToNode(node, resolved, generic);
+			const firstGeneric = node.generics[node.generics.length - 1];
+			node.superType = new GenerifiedTypeIdentifier(resolved.name, resolved.namespace.namespace, [firstGeneric.type]);
+		} else if (this.shouldUseNodeType(node, generic)) {
+			node.superType = new GenerifiedTypeIdentifier(resolved.name, resolved.namespace.namespace, [node.getType()]);
+		}
+	}
+
+	private shouldUseNodeType<T extends IntrospectedBaseClass>(node: T, generic: Generic): boolean {
+		return [...node.resolveParents()].some((c) => generic.defaultType && c.identifier.equals(generic.defaultType));
+	}
+
+	private processAsyncReadyCallback(node: IntrospectedFunctionParameter): IntrospectedFunctionParameter | null {
+		const unwrapped = node.type.unwrap();
+		if (!(unwrapped instanceof ClosureType)) {
+			return null;
+		}
+
+		const internal = unwrapped.type.unwrap();
+		if (!(internal instanceof TypeIdentifier) || !internal.is("Gio", "AsyncReadyCallback")) {
+			return null;
+		}
+
+		const member = node.parent;
+		if (!member) {
+			return null;
+		}
+
+		const generifiedType = this.createAsyncReadyCallbackType(member, internal);
+
+		if (generifiedType) {
+			return node.copy({
+				type: node.type.rewrap(generifiedType),
+			});
+		}
+
+		return null;
+	}
+
+	private createAsyncReadyCallbackType(
+		member:
+			| IntrospectedFunction
+			| IntrospectedClassFunction
+			| IntrospectedSignal
+			| IntrospectedConstructor
+			| IntrospectedDirectAllocationConstructor,
+		internal: TypeIdentifier,
+	): GenerifiedTypeIdentifier | null {
+		if (member instanceof IntrospectedFunction && member.parameters.length >= 2) {
+			return new GenerifiedTypeIdentifier(internal.name, internal.namespace, [member.parameters[0].type]);
+		}
+
+		if (member instanceof IntrospectedStaticClassFunction) {
+			return new GenerifiedTypeIdentifier(internal.name, internal.namespace, [member.parent.getType()]);
+		}
+
+		if (member instanceof IntrospectedClassFunction) {
+			return new GenerifiedTypeIdentifier(internal.name, internal.namespace, [ThisType]);
+		}
+
+		return null;
+	}
+
+	private createGenerifiedFunction(node: IntrospectedFunction, unwrapped: TypeIdentifier): IntrospectedFunction {
+		const genericReturnType = new GenericType("T", unwrapped);
+		const copied = node.copy({
+			return_type: genericReturnType,
+		});
+		copied.generics.push(new Generic(genericReturnType, unwrapped));
+		return copied;
+	}
+
+	private generifyStandaloneClassFunction<T extends IntrospectedClassFunction>(node: T): T {
+		if (this.shouldSkipFunctionGenerification(node)) {
+			return node;
+		}
+
+		const unwrapped = node.return().unwrap();
+
+		if (this.isGObjectType(unwrapped)) {
+			const genericReturnType = new GenericType("T", unwrapped as TypeIdentifier);
+			const copied = node.copy({
+				returnType: genericReturnType,
+			});
+			copied.generics.push(new Generic(genericReturnType, unwrapped as TypeIdentifier, unwrapped as TypeIdentifier));
+			return copied as T;
+		}
+
+		return node;
+	}
+
+	private shouldSkipFunctionGenerification<T extends IntrospectedClassFunction>(node: T): boolean {
+		return node.parent.getType().is("GObject", "Object");
+	}
+
+	private processClassFunctionWithGenerics<T extends IntrospectedBaseClass | IntrospectedEnum>(
+		node: IntrospectedClassFunction<T>,
+	): IntrospectedClassFunction<T> | null {
+		const clazz = node.parent as IntrospectedBaseClass;
+
+		if (clazz.generics.length === 0) {
+			return null;
+		}
+
+		const returnType = this.processReturnTypeWithGenerics(node.return(), clazz.generics);
+
+		return node.copy({
+			parameters: this.processParametersWithGenerics(node.parameters, clazz.generics),
+			outputParameters: this.processOutputParametersWithGenerics(node.output_parameters, clazz.generics),
+			returnType,
+		});
+	}
+
+	private processReturnTypeWithGenerics(returnType: TypeExpression, generics: Generic[]): TypeExpression {
+		for (const generic of generics) {
+			if (generic.defaultType?.equals(returnType.deepUnwrap())) {
+				return returnType.rewrap(generic.type);
+			}
+		}
+		return returnType;
+	}
+
+	private processParametersWithGenerics(
+		parameters: IntrospectedFunctionParameter[],
+		generics: Generic[],
+	): IntrospectedFunctionParameter[] {
+		return parameters.map((parameter) => this.processParameterWithGenerics(parameter, generics));
+	}
+
+	private processParameterWithGenerics(
+		parameter: IntrospectedFunctionParameter,
+		generics: Generic[],
+	): IntrospectedFunctionParameter {
+		for (const generic of generics) {
+			if (generic.defaultType?.equals(parameter.type.deepUnwrap())) {
+				return parameter.copy({
+					type: parameter.type.rewrap(generic.type),
+				});
+			}
+		}
+		return parameter;
+	}
+
+	private processOutputParametersWithGenerics(
+		outputParameters: IntrospectedFunctionParameter[],
+		generics: Generic[],
+	): IntrospectedFunctionParameter[] {
+		return outputParameters.map((parameter) => {
+			for (const generic of generics) {
+				if (generic.defaultType?.equals(parameter.type.unwrap())) {
+					return parameter.copy({
+						type: parameter.type.rewrap(generic.type),
+					});
+				}
+			}
+			return parameter;
+		});
+	}
+}

package/src/gir/alias.ts

@@ -0,0 +1,73 @@
+import type { FormatGenerator, GenericDescriptor } from "../generators/generator.ts";
+import type { TypeExpression } from "../gir.ts";
+import type { GirAliasElement } from "../index.ts";
+import type { IntrospectedOptions, OptionsLoad } from "../types/index.ts";
+import { parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { isIntrospectable } from "../utils/girs.ts";
+import { sanitizeIdentifierName } from "../utils/naming.ts";
+import { getAliasType } from "../utils/types.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedNamespaceMember } from "./introspected-namespace-member.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+
+export class IntrospectedAlias extends IntrospectedNamespaceMember {
+	readonly type: TypeExpression;
+	readonly generics: GenericDescriptor[];
+
+	constructor({
+		namespace,
+		name,
+		type,
+		generics = [],
+		...args
+	}: IntrospectedOptions<{
+		namespace: IntrospectedNamespace;
+		name: string;
+		type: TypeExpression;
+		generics?: GenericDescriptor[];
+	}>) {
+		super(name, namespace, { ...args });
+
+		this.type = type;
+		this.generics = generics;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedAlias {
+		const node = this.copy({
+			type: visitor.visitType?.(this.type),
+		});
+
+		return visitor.visitAlias?.(node) ?? node;
+	}
+
+	copy(options?: { parent?: undefined; type?: TypeExpression }): IntrospectedAlias {
+		const { name, namespace, type } = this;
+
+		return new IntrospectedAlias({ name, namespace, type: options?.type ?? type })._copyBaseProperties(this);
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateAlias"]> {
+		return generator.generateAlias(this) as ReturnType<T["generateAlias"]>;
+	}
+
+	static fromXML(element: GirAliasElement, ns: IntrospectedNamespace, options: OptionsLoad): IntrospectedAlias | null {
+		if (!element.$.name) {
+			console.error(`Alias in ${ns.namespace} lacks name.`);
+			return null;
+		}
+
+		const alias = new IntrospectedAlias({
+			namespace: ns,
+			name: sanitizeIdentifierName(ns.namespace, element.$.name),
+			type: getAliasType(ns.namespace, ns, element),
+			isIntrospectable: isIntrospectable(element),
+		});
+
+		if (options.loadDocs) {
+			alias.doc = parseDoc(element);
+			alias.metadata = parseMetadata(element);
+		}
+
+		return alias;
+	}
+}

package/src/gir/callback.ts

@@ -0,0 +1,79 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import { FunctionType, type TypeExpression } from "../gir.ts";
+import type { GirCallbackElement, GirModule } from "../index.ts";
+import type { OptionsLoad } from "../types/index.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedFunction } from "./function.ts";
+import type { IntrospectedFunctionParameter } from "./parameter.ts";
+
+export class IntrospectedCallback extends IntrospectedFunction {
+	asFunctionType(): FunctionType {
+		return new FunctionType(
+			Object.fromEntries(this.parameters.map((p) => [p.name, p.type] as const)),
+			this.return_type,
+		);
+	}
+
+	copy({
+		parameters,
+		returnType,
+		outputParameters,
+		parent,
+	}: {
+		parent?: GirModule;
+		parameters?: IntrospectedFunctionParameter[];
+		outputParameters?: IntrospectedFunctionParameter[];
+		returnType?: TypeExpression;
+	} = {}): IntrospectedCallback {
+		const cb = new IntrospectedCallback({
+			name: this.name,
+			raw_name: this.raw_name,
+			return_type: returnType ?? this.return_type,
+			parameters: parameters ?? this.parameters,
+			output_parameters: outputParameters ?? this.output_parameters,
+			namespace: parent ?? this.parent,
+		})._copyBaseProperties(this);
+
+		cb.generics = [...this.generics];
+
+		return cb;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedCallback {
+		const node = this.copy({
+			parameters: this.parameters.map((p) => {
+				return p.accept(visitor);
+			}),
+			outputParameters: this.output_parameters.map((p) => {
+				return p.accept(visitor);
+			}),
+			returnType: visitor.visitType?.(this.return_type),
+		});
+
+		return visitor.visitCallback?.(node) ?? node;
+	}
+
+	static fromXML(element: GirCallbackElement, namespace: GirModule, options: OptionsLoad): IntrospectedCallback {
+		const ns = namespace;
+		const cb = new IntrospectedCallback(IntrospectedFunction.fromXML(element, ns, options).getCallbackParameters());
+
+		const glibTypeName = element.$["glib:type-name"];
+		if (typeof glibTypeName === "string" && element.$["glib:type-name"]) {
+			cb.resolve_names.push(glibTypeName);
+
+			ns.registerResolveName(glibTypeName, ns.namespace, cb.name);
+		}
+
+		if (element.$["c:type"]) {
+			cb.resolve_names.push(element.$["c:type"]);
+
+			ns.registerResolveName(element.$["c:type"], ns.namespace, cb.name);
+		}
+
+		return cb;
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateCallback"]> {
+		return generator.generateCallback(this) as ReturnType<T["generateCallback"]>;
+	}
+}

package/src/gir/const.ts

@@ -0,0 +1,73 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import type { TypeExpression } from "../gir.ts";
+
+import type { GirConstantElement } from "../index.ts";
+import type { IntrospectedOptions, OptionsLoad } from "../types/index.ts";
+import { getType, parseDoc, parseMetadata } from "../utils/gir-parsing.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";
+
+export class IntrospectedConstant extends IntrospectedNamespaceMember {
+	type: TypeExpression;
+	value: string | null;
+
+	constructor({
+		name,
+		type,
+		namespace,
+		value,
+		...options
+	}: IntrospectedOptions<{
+		name: string;
+		type: TypeExpression;
+		namespace: IntrospectedNamespace;
+		value: string | null;
+		isIntrospectable?: boolean;
+	}>) {
+		super(name, namespace, options);
+
+		this.type = type;
+		this.value = value;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedConstant {
+		const node = this.copy({
+			type: visitor.visitType?.(this.type),
+		});
+
+		return visitor.visitConst?.(node) ?? node;
+	}
+
+	copy(options: { parent?: IntrospectedNamespace; type?: TypeExpression } = {}): IntrospectedConstant {
+		const { type, name, value } = this;
+
+		return new IntrospectedConstant({
+			name,
+			namespace: options.parent ?? this.namespace,
+			type: options.type ?? type,
+			value,
+		})._copyBaseProperties(this);
+	}
+
+	static fromXML(element: GirConstantElement, ns: IntrospectedNamespace, options: OptionsLoad): IntrospectedConstant {
+		const c = new IntrospectedConstant({
+			name: sanitizeIdentifierName(ns.namespace, element.$.name),
+			namespace: ns,
+			type: getType(ns, element),
+			value: element.$.value ?? null,
+		});
+
+		if (options.loadDocs) {
+			c.doc = parseDoc(element);
+			c.metadata = parseMetadata(element);
+		}
+
+		return c;
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateConst"]> {
+		return generator.generateConst(this) as ReturnType<T["generateConst"]>;
+	}
+}