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

package/package.json

@@ -1,60 +1,60 @@
 {
-  "name": "@ts-for-gir/lib",
-  "version": "4.0.0-rc.9",
-  "description": "Typescript .d.ts generator from GIR for gjs",
-  "main": "src/index.ts",
-  "module": "src/index.ts",
-  "type": "module",
-  "engines": {
-    "node": ">=18"
-  },
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "scripts": {
-    "check": "tsc --noEmit"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gjsify/ts-for-gir.git"
-  },
-  "author": "Pascal Garber <pascal@mailfreun.de>",
-  "files": [
-    "src"
-  ],
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/gjsify/ts-for-gir/issues"
-  },
-  "homepage": "https://github.com/gjsify/ts-for-gir#readme",
-  "keywords": [
-    "gjs",
-    "typescript",
-    "generate",
-    "gir",
-    "gobject-introspection",
-    "gnome",
-    "gtk",
-    "glib",
-    "gobject",
-    "dts",
-    "type definitions"
-  ],
-  "devDependencies": {
-    "@ts-for-gir/tsconfig": "^4.0.0-rc.9",
-    "@types/ejs": "^3.1.5",
-    "@types/lodash": "^4.17.24",
-    "@types/node": "^25.6.0",
-    "rimraf": "^6.1.3",
-    "typescript": "^6.0.3"
-  },
-  "dependencies": {
-    "@gi.ts/parser": "^4.0.0-rc.9",
-    "@ts-for-gir/reporter": "^4.0.0-rc.9",
-    "@ts-for-gir/templates": "^4.0.0-rc.9",
-    "colorette": "^2.0.20",
-    "ejs": "^5.0.2",
-    "glob": "^13.0.6",
-    "lodash": "4.18.1"
-  }
-}
+	"name": "@ts-for-gir/lib",
+	"version": "4.0.1",
+	"description": "Typescript .d.ts generator from GIR for gjs",
+	"main": "src/index.ts",
+	"module": "src/index.ts",
+	"type": "module",
+	"engines": {
+		"node": ">=18"
+	},
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"scripts": {
+		"check": "tsc --noEmit"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gjsify/ts-for-gir.git"
+	},
+	"author": "Pascal Garber <pascal@mailfreun.de>",
+	"files": [
+		"src"
+	],
+	"license": "Apache-2.0",
+	"bugs": {
+		"url": "https://github.com/gjsify/ts-for-gir/issues"
+	},
+	"homepage": "https://github.com/gjsify/ts-for-gir#readme",
+	"keywords": [
+		"gjs",
+		"typescript",
+		"generate",
+		"gir",
+		"gobject-introspection",
+		"gnome",
+		"gtk",
+		"glib",
+		"gobject",
+		"dts",
+		"type definitions"
+	],
+	"devDependencies": {
+		"@ts-for-gir/tsconfig": "^4.0.1",
+		"@types/ejs": "^3.1.5",
+		"@types/lodash": "^4.17.24",
+		"@types/node": "^25.6.2",
+		"rimraf": "^6.1.3",
+		"typescript": "^6.0.3"
+	},
+	"dependencies": {
+		"@gi.ts/parser": "^4.0.1",
+		"@ts-for-gir/reporter": "^4.0.1",
+		"@ts-for-gir/templates": "^4.0.1",
+		"colorette": "^2.0.20",
+		"ejs": "^5.0.2",
+		"glob": "^13.0.6",
+		"lodash": "4.18.1"
+	}
+}

package/src/gir/function.ts

@@ -4,7 +4,7 @@ import {
 	ArrayType,
 	ClosureType,
 	type Generic,
-	NullableType,
+	makeNullable,
 	type TypeExpression,
 	TypeIdentifier,
 	UnknownType,
@@ -259,7 +259,7 @@ export class IntrospectedFunction extends IntrospectedNamespaceMember {
 						}
 					} else {
 						if (isOptional) {
-							params.push(p.copy({ type: new NullableType(type), isOptional: false }));
+							params.push(p.copy({ type: makeNullable(type), isOptional: false }));
 						} else {
 							params.push(p);
 						}

package/src/gir/introspected-classes.ts

@@ -5,6 +5,7 @@ import {
 	Generic,
 	GenericType,
 	GenerifiedTypeIdentifier,
+	makeNullable,
 	NullableType,
 	type TypeExpression,
 	TypeIdentifier,
@@ -77,7 +78,7 @@ function resolveNullableProperties(cls: IntrospectedBaseClass): void {
 		const getter = cls.members.find((m) => m.name === getterName && !(m instanceof IntrospectedStaticClassFunction));
 
 		if (getter instanceof IntrospectedClassFunction && getter.return() instanceof NullableType) {
-			prop.type = new NullableType(prop.type);
+			prop.type = makeNullable(prop.type);
 		}
 	}
 }

package/src/gir/namespace.ts

@@ -1,4 +1,4 @@
-import { BinaryType, BooleanType, ClosureType, PromiseType, TupleType, TypeIdentifier, VoidType } from "../gir.ts";
+import { BooleanType, ClosureType, makeUnion, PromiseType, TupleType, TypeIdentifier, VoidType } from "../gir.ts";
 
 import type { GirModule } from "../gir-module.ts";
 import type { IntrospectedAlias } from "./alias.ts";
@@ -65,7 +65,7 @@ export function promisifyNamespaceFunctions(namespace: GirModule) {
 						parameters: sync_parameters,
 					}),
 					node.copy({
-						return_type: new BinaryType(async_return, node.return()),
+						return_type: makeUnion(async_return, node.return()),
 					}),
 				]);
 			}

package/src/gir/promisify.ts

@@ -1,4 +1,4 @@
-import { BinaryType, BooleanType, ClosureType, PromiseType, TupleType, TypeIdentifier, VoidType } from "../gir.ts";
+import { BooleanType, ClosureType, makeUnion, PromiseType, TupleType, TypeIdentifier, VoidType } from "../gir.ts";
 import { IntrospectedConstructor } from "./constructor.ts";
 import type { IntrospectedClassFunction } from "./introspected-classes.ts";
 import {
@@ -42,7 +42,7 @@ function generatePromisifyOverloadedSignatures(
 	// Union overload (with optional callback)
 	const unionOverload = node.copy({
 		parameters: [...async_parameters, sync_parameters[sync_parameters.length - 1].copy({ isOptional: true })],
-		returnType: new BinaryType(async_return, VoidType),
+		returnType: makeUnion(async_return, VoidType),
 	});
 
 	return [promiseOverload, callbackOverload, unionOverload];

package/src/gir/property.ts

@@ -1,5 +1,5 @@
 import type { FormatGenerator } from "../generators/generator.ts";
-import { NullableType, type TypeExpression } from "../gir.ts";
+import { makeNullable, type TypeExpression } from "../gir.ts";
 import type { GirFieldElement, GirPropertyElement } from "../index.ts";
 import type { OptionsLoad } from "../types/index.ts";
 import type { Options } from "../types/introspected.ts";
@@ -210,7 +210,7 @@ export class IntrospectedProperty extends IntrospectedBase<IntrospectedEnum | In
 		property.getter = element.$.getter;
 
 		if (element.$.nullable === "1" || element.$["allow-none"] === "1") {
-			property.type = new NullableType(property.type);
+			property.type = makeNullable(property.type);
 		}
 
 		return property;

package/src/gir/signal.ts

@@ -3,6 +3,7 @@ import { GirDirection } from "@gi.ts/parser";
 import type { FormatGenerator } from "../generators/generator.ts";
 import {
 	ArrayType,
+	makeNullable,
 	NativeType,
 	NullableType,
 	NumberType,
@@ -171,7 +172,7 @@ export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClas
 						}
 					} else {
 						if (isOptional) {
-							params.push(p.copy({ type: new NullableType(type), isOptional: false }));
+							params.push(p.copy({ type: makeNullable(type), isOptional: false }));
 						} else {
 							params.push(p);
 						}

package/src/gir.ts

@@ -348,9 +348,9 @@ export class NativeType extends TypeExpression {
 export class OrType extends TypeExpression {
 	readonly types: ReadonlyArray<TypeExpression>;
 
-	constructor(type: TypeExpression, ...types: TypeExpression[]) {
+	constructor(...types: TypeExpression[]) {
 		super();
-		this.types = [type, ...types];
+		this.types = [...types];
 	}
 
 	rewrap(type: TypeExpression): TypeExpression {
@@ -362,17 +362,15 @@ export class OrType extends TypeExpression {
 	}
 
 	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
-		const [type, ...types] = this.types;
-
-		return new OrType(type.resolve(namespace, options), ...types.map((t) => t.resolve(namespace, options)));
+		return makeUnion(...this.types.map((t) => t.resolve(namespace, options)));
 	}
 
 	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
-		return `(${this.types.map((t) => t.print(namespace, options)).join(" | ")})`;
+		return `${this.types.map((t) => t.print(namespace, options)).join(" | ")}`;
 	}
 
 	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
-		return `${this.types.map((t) => t.print(namespace, options)).join(" | ")}`;
+		return this.print(namespace, options);
 	}
 
 	equals(type: TypeExpression) {
@@ -384,6 +382,36 @@ export class OrType extends TypeExpression {
 	}
 }
 
+export function makeUnion(...inputTypes: TypeExpression[]) {
+	const types: Set<TypeExpression> = new Set();
+	for (const type of inputTypes) {
+		if (type instanceof BinaryType) {
+			types.add(type.a);
+			types.add(type.b);
+		} else if (type instanceof OrType && !(type instanceof TupleType)) {
+			for (const t of type.types) {
+				types.add(t);
+			}
+		} else {
+			types.add(type);
+		}
+	}
+	if (types.size === 1) {
+		return [...types][0];
+	}
+	if (types.size === 2) {
+		const typesArray = [...types];
+		if (typesArray[0] === NullType) {
+			return new NullableType(typesArray[1]);
+		}
+		if (typesArray[1] === NullType) {
+			return new NullableType(typesArray[0]);
+		}
+		return new BinaryType(...typesArray);
+	}
+	return new OrType(...types);
+}
+
 export class TupleType extends OrType {
 	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `[${this.types.map((t) => t.print(namespace, options)).join(", ")}]`;
@@ -624,7 +652,7 @@ export class NullableType extends BinaryType {
 	}
 
 	rewrap(type: TypeExpression): TypeExpression {
-		return new NullableType(this.a.rewrap(type));
+		return makeNullable(this.a.rewrap(type));
 	}
 
 	get type() {
@@ -632,6 +660,13 @@ export class NullableType extends BinaryType {
 	}
 }
 
+export function makeNullable(type: TypeExpression) {
+	if (type instanceof NullableType) return type;
+	if (type === RawPointerType) return NullType;
+	if (type === AnyType) return AnyType;
+	return makeUnion(type, NullType);
+}
+
 export class PromiseType extends TypeExpression {
 	type: TypeExpression;
 
@@ -828,6 +863,8 @@ export class ArrayType extends TypeExpression {
 			typeSuffix = "".padStart(2 * depth, "[]");
 		}
 
+		if (this.type instanceof OrType && !(this.type instanceof TupleType))
+			return `(${this.type.print(namespace, options)})${typeSuffix}`;
 		return `${this.type.print(namespace, options)}${typeSuffix}`;
 	}
 
@@ -866,5 +903,8 @@ export const NullType = new NativeType("null");
 export const VoidType = new NativeType("void");
 export const UnknownType = new NativeType("unknown");
 export const AnyFunctionType = new NativeType("(...args: any[]) => any");
+// Distinct from NeverType, so that we can transform it into NullType when
+// marshalled from C to JS
+export const RawPointerType = new NativeType("never");
 
 export type GirClassField = IntrospectedProperty | IntrospectedField;

package/src/injections/shell.ts

@@ -1,6 +1,6 @@
 import type { IntrospectedNamespace } from "../gir/namespace.ts";
 import type { NSRegistry } from "../gir/registry.ts";
-import { NullableType, OrType, TypeIdentifier } from "../gir.ts";
+import { makeUnion, NullType, TypeIdentifier } from "../gir.ts";
 
 const shellTemplate = (version: string) => ({
 	namespace: "Shell",
@@ -24,8 +24,10 @@ const shellTemplate = (version: string) => ({
 		if (addGlslSnippet) {
 			// Create a new parameter with updated type using copy()
 			const updatedParameter = addGlslSnippet.parameters[0].copy({
-				type: new NullableType(
-					new OrType(new TypeIdentifier("SnippetHook", "Shell"), new TypeIdentifier("SnippetHook", "Cogl")),
+				type: makeUnion(
+					new TypeIdentifier("SnippetHook", "Shell"),
+					new TypeIdentifier("SnippetHook", "Cogl"),
+					NullType,
 				),
 			});
 

package/src/utils/gir-parsing.ts

@@ -17,8 +17,8 @@ import {
 	BigintOrNumberType,
 	ClosureType,
 	GenerifiedTypeIdentifier,
+	makeNullable,
 	NativeType,
-	NullableType,
 	type TypeExpression,
 	TypeIdentifier,
 	VoidType,
@@ -242,11 +242,11 @@ export function getType(
 		!(variableType instanceof NativeType) &&
 		variableType !== BigintOrNumberType
 	) {
-		return new NullableType(variableType);
+		return makeNullable(variableType);
 	}
 
 	if ((!parameter.$?.direction || parameter.$.direction === GirDirection.In) && nullable) {
-		return new NullableType(variableType);
+		return makeNullable(variableType);
 	}
 
 	variableType.isPointer = isPointer;

package/src/utils/types.ts

@@ -7,17 +7,21 @@ import {
 	BigintOrNumberType,
 	BinaryType,
 	BooleanType,
+	GenerifiedTypeIdentifier,
+	makeNullable,
+	makeUnion,
 	NativeType,
 	NeverType,
 	NullableType,
+	NullType,
 	NumberType,
 	ObjectType,
-	OrType,
 	PromiseType,
+	RawPointerType,
 	StringType,
 	ThisType,
 	TupleType,
-	type TypeExpression,
+	TypeExpression,
 	TypeIdentifier,
 	Uint8ArrayType,
 	UnknownType,
@@ -188,8 +192,13 @@ export function resolvePrimitiveType(name: string): TypeExpression | null {
 			return BigintOrNumberType;
 		case "gboolean":
 			return BooleanType;
-		case "gpointer": // This is typically used in callbacks to pass data, so we'll allow anything.
-			return AnyType;
+		case "gpointer":
+			// You can't use pointers. Pointer arguments are mostly not exposed
+			// in GJS, but any exposed pointer arguments are always marshalled
+			// as null pointers. If the argument is nullable, this will combine
+			// with `null` to produce `null`, but if the argument isn't nullable
+			// it's impossible to pass a valid parameter to the function.
+			return RawPointerType;
 		case "object": // Support TS "object"
 			return ObjectType;
 		case "va_list":
@@ -224,52 +233,193 @@ export function resolveDirectedType(type: TypeExpression, direction: GirDirectio
 			type.type.equals(Uint8ArrayType) &&
 			type.arrayDepth === 0
 		) {
-			return new BinaryType(type, StringType);
+			return makeUnion(type, StringType);
 		} else {
 			// Rewrap arrays if they have directional types
 			return type.rewrap(resolveDirectedType(type.type, direction) ?? type.type);
 		}
 	} else if (type instanceof TypeIdentifier) {
 		if ((direction === GirDirection.In || direction === GirDirection.Inout) && type.is("GLib", "Bytes")) {
-			return new BinaryType(type, Uint8ArrayType);
+			return makeUnion(type, Uint8ArrayType);
 		} else if (type.is("GObject", "Value")) {
 			if (direction === GirDirection.In || direction === GirDirection.Inout) {
-				return new BinaryType(type, AnyType);
+				return makeUnion(type, AnyType);
 			} else {
 				// GJS converts GObject.Value out parameters to their unboxed type, which we don't know,
 				// so type as `unknown`
 				return UnknownType;
 			}
 		} else if (type.is("GLib", "HashTable")) {
-			if (direction === GirDirection.In) {
-				// Intentional `any` — GLib.HashTable maps to a JS dict with dynamic values in generated output
-				return new BinaryType(new NativeType("{ [key: string]: any }"), type);
-			} else {
-				return type;
-			}
+			// GJS marshalls `GHashTable<K, V>` to and from a plain JS object
+			// in both directions — only string-typed keys (`utf8`, `filename`)
+			// and integer-typed keys (`bool`, signed/unsigned 8/16/32-bit
+			// ints) are supported. `gunichar` accepts either string or
+			// integer. Anything else throws during marshalling — see
+			// https://gitlab.gnome.org/GNOME/gjs/-/blob/main/gi/arg.cpp#L316-420
+			// and the discussion at
+			// https://github.com/gjsify/ts-for-gir/issues/392.
+			//
+			// The TS type `GLib.HashTable<K, V>` does not represent any value
+			// that user code can actually hold — there's no GHashTable
+			// constructor exposed to JS. So in EVERY direction we emit the
+			// concrete JS shape (`{ [key: string]: V }` for string-keyed,
+			// `{ [key: number]: V }` for integer-keyed) and fall back to
+			// `never` when the declared key type can't be marshalled —
+			// statically encoding that the function can't be called rather
+			// than silently lying with a HashTable type that has no runtime
+			// instances.
+			return hashTableToJsDict(type);
 		}
 	} else if (type === BigintOrNumberType && direction === GirDirection.Out) {
 		// 64-bit integers accept number or bigint, but only return number to JS
 		return NumberType;
+	} else if (type === RawPointerType && direction === GirDirection.Out) {
+		// Raw pointers are always marshalled as JS null.
+		return NullType;
 	} else if (type instanceof PromiseType) {
 		// Propagate direction into the Promise's inner type so e.g. async
 		// functions returning 64-bit ints resolve to `Promise<number>` rather
 		// than `Promise<bigint | number>`.
 		const resolvedInner = resolveDirectedType(type.type, direction);
 		if (resolvedInner) return new PromiseType(resolvedInner);
-	} else if (type instanceof BinaryType && !(type instanceof NullableType)) {
+	} else if (type instanceof NullableType) {
+		// Walk into the wrapped type and rebuild as NullableType so e.g.
+		// `GLib.HashTable<string, string> | null` becomes
+		// `{ [key: string]: string } | null` (without the rebuild, the
+		// outer NullableType-aware BinaryType branch below would skip
+		// this case to preserve NullableType identity, leaving the inner
+		// type unrewritten).
+		const inner = resolveDirectedType(type.a, direction);
+		if (inner !== null) return makeNullable(inner);
+	} else if (type instanceof TupleType) {
+		// Walk into each tuple element so a `[HashTable<string, V>, …]`
+		// (typical async [result, out-params, …] shape) gets each element
+		// rewritten. BinaryType's branch below would also match TupleType
+		// since it extends OrType → BinaryType is one of its supertypes,
+		// but the rebuild via `makeUnion` would collapse tuple semantics
+		// into a union — preserve the tuple by rebuilding the same class.
+		let changed = false;
+		const inner = type.types.map((t) => {
+			const resolved = resolveDirectedType(t, direction);
+			if (resolved !== null) {
+				changed = true;
+				return resolved;
+			}
+			return t;
+		});
+		if (changed) {
+			const [first, ...rest] = inner;
+			return new TupleType(first, ...rest);
+		}
+	} else if (type instanceof BinaryType) {
 		// Walk through binary unions like `Promise<T> | void` (the dual-call
 		// async overload) so the inner types still get direction propagation.
-		// NullableType is skipped to preserve its subclass behaviour.
 		const a = resolveDirectedType(type.a, direction) ?? type.a;
 		const b = resolveDirectedType(type.b, direction) ?? type.b;
-		if (a !== type.a || b !== type.b) return new BinaryType(a, b);
-	} else if (type instanceof OrType && !(type instanceof BinaryType || type instanceof TupleType)) {
-		// flatten "bigint | number" out of another OR-type
-		const types = type.types.map((t) => resolveDirectedType(t, direction) ?? t);
-		if (types.length === 1) return types[0];
-		return new OrType(types[0], ...types.slice(1));
+		if (a !== type.a || b !== type.b) return makeUnion(a, b);
+	}
+
+	return null;
+}
+
+/**
+ * Map a `GLib.HashTable<K, V>` reference to the concrete JS object shape
+ * GJS marshals it to/from. Direction-independent — the marshalling is
+ * symmetric (a method that accepts a HashTable and a method that returns
+ * one both see a plain object on the JS side).
+ *
+ * Key-type rules (per gi/arg.cpp's `gjs_value_from_g_hash` /
+ * `gjs_value_to_g_hash`):
+ *
+ *   string-shaped (`utf8`, `filename`)                 → `{ [key: string]: V }`
+ *   integer-shaped (`gboolean`, `gint8`…`guint32`)      → `{ [key: number]: V }`
+ *   `gunichar`                                         → `{ [key: string]: V }`
+ *                                                        (also accepts numbers,
+ *                                                        but the broader string
+ *                                                        case is more useful)
+ *   anything else (raw pointers, classes, records, …)  → `never`
+ *                                                        (uncallable on the JS side)
+ *
+ * The fallback for "type information missing" (e.g. an introspection
+ * record with bare `HashTable` and no generics) is `{ [key: string]: any }`
+ * — the most common shape, matching the historical generator output.
+ */
+function hashTableToJsDict(type: TypeIdentifier): TypeExpression {
+	if (!(type instanceof GenerifiedTypeIdentifier) || type.generics.length === 0) {
+		// Bare `HashTable` with no generics — emit the catch-all dict shape.
+		return new NativeType("{ [key: string]: any }");
+	}
+
+	const [keyType, valueType] = type.generics;
+	const keyShape = jsKeyShapeFor(keyType);
+	if (keyShape === null) {
+		// Unsupported key type — function is uncallable from JS.
+		return NeverType;
 	}
 
+	// Return a TypeExpression subclass that defers printing of V until a
+	// real namespace is available (which is the case both at type-resolve
+	// time and at template-emit time). A plain `NativeType((options) =>
+	// …)` would not work — its callback receives only `options`, not the
+	// namespace V's own print needs.
+	return new HashTableDictType(keyShape, valueType ?? AnyType);
+}
+
+/**
+ * Decide which TypeScript index-signature key type a GHashTable key maps to.
+ * Returns `null` for unsupported key types — the caller emits `never` so the
+ * containing method/property surfaces as uncallable rather than lying with a
+ * synthetic key type that doesn't match runtime marshalling.
+ */
+function jsKeyShapeFor(keyType: TypeExpression): "string" | "number" | null {
+	if (keyType === StringType) return "string";
+	if (keyType instanceof TypeIdentifier && keyType.is("GLib", "filename")) return "string";
+	// Integer-shaped keys: signed/unsigned 8/16/32-bit ints + gboolean
+	// (0/1 number) all collapse to TS `number`. 64-bit ints accept either
+	// number or bigint at the JS boundary; pick `number` for index keys
+	// since object keys are always strings/numbers in JS (no bigint keys).
+	if (keyType === NumberType) return "number";
+	if (keyType === BooleanType) return "number";
+	if (keyType === BigintOrNumberType) return "number";
 	return null;
 }
+
+/**
+ * `{ [key: K]: V }` shape for `GLib.HashTable<K, V>` — a TypeExpression
+ * subclass so `V.rootPrint(namespace, options)` happens at emit time with
+ * the right namespace, instead of being baked in at type-resolve time.
+ */
+class HashTableDictType extends TypeExpression {
+	constructor(
+		readonly keyShape: "string" | "number",
+		readonly valueType: TypeExpression,
+	) {
+		super();
+	}
+
+	print(namespace: IntrospectedNamespace, options: import("../types/index.ts").OptionsGeneration): string {
+		return `{ [key: ${this.keyShape}]: ${this.valueType.rootPrint(namespace, options)} }`;
+	}
+
+	resolve(_namespace: IntrospectedNamespace, _options: import("../types/index.ts").OptionsGeneration): TypeExpression {
+		return this;
+	}
+
+	equals(type: TypeExpression): boolean {
+		return (
+			type instanceof HashTableDictType && this.keyShape === type.keyShape && this.valueType.equals(type.valueType)
+		);
+	}
+
+	rewrap(_type: TypeExpression): TypeExpression {
+		return this;
+	}
+
+	unwrap(): TypeExpression {
+		return this;
+	}
+
+	deepUnwrap(): TypeExpression {
+		return this.valueType.deepUnwrap();
+	}
+}