gofront 1.7.0 → 1.9.0

package/src/backend/wasm/types.js

@@ -2,23 +2,13 @@
 // Maps GoFront types to WasmGC types and manages type registry.
 
 import { SHARED_KINDS } from "../../typechecker/stdlib/shared.js";
+import { isComplex, isComplex64 } from "../../typechecker/types.js";
+
+export { isComplex, isComplex64 };
 
 // Name of the runtime's error struct (`errors.New`, `fmt.Errorf`, strconv).
 export const ERROR_STRUCT = "__errorString";
 
-// `*testing.T` is a JS-side object (the harness's __GoFront_T) passed through
-// the boundary as an opaque externref.
-export function isTestingT(goType) {
-	if (!goType) return false;
-	const base =
-		goType.kind === "pointer" || goType.kind === "PointerType"
-			? goType.base
-			: goType.kind === "StarExpr"
-				? (goType.expr ?? goType.operand)
-				: null;
-	return base?.name === "testing.T";
-}
-
 export function toWasmType(goType, checker = null, mod = null) {
 	if (!goType) return "i32";
 	if (typeof goType === "string") {
@@ -38,7 +28,6 @@ export function toWasmType(goType, checker = null, mod = null) {
 	if (typeof goType === "object" && goType.kind === "ref") {
 		return goType;
 	}
-	if (isTestingT(goType)) return "externref";
 
 	if (
 		goType.kind === "simd" ||
@@ -105,16 +94,25 @@ export function toWasmType(goType, checker = null, mod = null) {
 		) {
 			return "v128";
 		}
-		if (mod?.getStructType(goType.name)) {
+		// An instance written `Box[int]` is the monomorphised struct `Box$int`.
+		const instance = goType.typeArgs?.length
+			? mod?.getStructType(`${goType.name}$${instanceArgsKey(goType.typeArgs)}`)
+			: null;
+		const struct = instance ?? mod?.getStructType(goType.name);
+		if (struct) {
 			return {
 				kind: "ref",
 				nullable: true,
-				typeIndex: mod.getStructType(goType.name).typeIndex,
+				typeIndex: struct.typeIndex,
 			};
 		}
 		if (goType.underlying) {
 			return toWasmType(goType.underlying, checker, mod);
 		}
+		// A bare `{ kind: "named", name }` (method receivers): look it up.
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved?.underlying)
+			return toWasmType(resolved.underlying, checker, mod);
 	}
 
 	// Untyped constants
@@ -128,6 +126,17 @@ export function toWasmType(goType, checker = null, mod = null) {
 				return "externref";
 			case "bool":
 				return "i32";
+			case "complex128":
+				if (mod?.getComplexType) {
+					const info = mod.getComplexType("complex128");
+					return {
+						kind: "ref",
+						nullable: true,
+						typeIndex: info.typeIndex,
+						typeName: info.name,
+					};
+				}
+				return { kind: "ref", nullable: true, heapType: "struct" };
 			default:
 				return "i64";
 		}
@@ -159,6 +168,32 @@ export function toWasmType(goType, checker = null, mod = null) {
 			case "float64":
 				return "f64";
 
+			case "complex64": {
+				if (mod?.getComplexType) {
+					const info = mod.getComplexType("complex64");
+					return {
+						kind: "ref",
+						nullable: true,
+						typeIndex: info.typeIndex,
+						typeName: info.name,
+					};
+				}
+				return { kind: "ref", nullable: true, heapType: "struct" };
+			}
+
+			case "complex128": {
+				if (mod?.getComplexType) {
+					const info = mod.getComplexType("complex128");
+					return {
+						kind: "ref",
+						nullable: true,
+						typeIndex: info.typeIndex,
+						typeName: info.name,
+					};
+				}
+				return { kind: "ref", nullable: true, heapType: "struct" };
+			}
+
 			case "string":
 				return "externref";
 
@@ -181,14 +216,32 @@ export function toWasmType(goType, checker = null, mod = null) {
 			if (
 				typeof baseWType === "object" &&
 				baseWType !== null &&
-				baseWType.kind === "ref"
+				baseWType.kind === "ref" &&
+				// A pointer to a slice or map goes through the scalar box:
+				// the pointee is a replaceable reference value.
+				!isReplaceableRef(goType.base, checker)
 			) {
 				return baseWType;
 			}
-			if (mod?.getBoxType) {
+			if (mod?.getPtrType) {
+				const ptr = mod.getPtrType(goType.base);
+				if (mod.getBoxType) mod.getBoxType(goType.base);
+				if (ptr)
+					return {
+						kind: "ref",
+						nullable: true,
+						typeIndex: ptr.typeIndex,
+						typeName: ptr.name,
+					};
+			} else if (mod?.getBoxType) {
 				const box = mod.getBoxType(goType.base);
 				if (box)
-					return { kind: "ref", nullable: true, typeIndex: box.typeIndex };
+					return {
+						kind: "ref",
+						nullable: true,
+						typeIndex: box.typeIndex,
+						typeName: box.name,
+					};
 			}
 		}
 		return { kind: "ref", nullable: true, heapType: "any" };
@@ -262,10 +315,8 @@ export function toWasmType(goType, checker = null, mod = null) {
 					for (const n of names) rawFields.push({ name: n, goType: f.type });
 				}
 			}
-			if (rawFields.length > 0) {
-				const info = mod.getAnonStructType(rawFields);
-				return { kind: "ref", nullable: true, typeIndex: info.typeIndex };
-			}
+			const info = mod.getAnonStructType(rawFields);
+			return { kind: "ref", nullable: true, typeIndex: info.typeIndex };
 		}
 		return { kind: "ref", nullable: true, heapType: "struct" };
 	}
@@ -294,14 +345,19 @@ export function getInterfaceMethodList(iface) {
 	if (iface.methods instanceof Map) {
 		return Array.from(iface.methods.entries()).map(([name, sig]) => ({
 			name,
-			params: (sig.params ?? []).map((p) => p.type ?? p),
+			params: variadicAsSlice(
+				(sig.params ?? []).map((p) => p.type ?? p),
+				sig.variadic,
+			),
 			returns: (sig.returns ?? []).map((r) => r.type ?? r),
 		}));
 	}
 	if (Array.isArray(iface.methods)) {
 		return iface.methods.map((m) => ({
 			name: m.name?.value ?? m.name ?? m,
-			params: (m.params ?? []).map((p) => p.type ?? p),
+			params: (m.params ?? []).map((p) =>
+				p.variadic ? { kind: "SliceType", elem: p.type } : (p.type ?? p),
+			),
 			returns: m.returnType
 				? m.returnType.kind === "TupleType" || m.returnType.kind === "tuple"
 					? m.returnType.types
@@ -312,6 +368,12 @@ export function getInterfaceMethodList(iface) {
 	return [];
 }
 
+// The type-argument part of a monomorphised name (see monomorph.js typeKey):
+// the dot of a qualified argument is replaced to keep the name an identifier.
+function instanceArgsKey(typeArgs) {
+	return typeArgs.map(goTypeKey).join("$").replaceAll(".", "_");
+}
+
 export function goTypeKey(t) {
 	if (!t) return "any";
 	if (typeof t === "string") {
@@ -361,6 +423,9 @@ export function goTypeKey(t) {
 		return `struct_${rawFields.join("_")}`;
 	}
 	if (t.kind === "named") {
+		// An instance of a generic type is the monomorphised `Box$int`.
+		if (t.name && t.typeArgs?.length && !t.name.includes("$"))
+			return `${t.name}$${instanceArgsKey(t.typeArgs)}`;
 		return t.name ?? (t.underlying ? goTypeKey(t.underlying) : "any");
 	}
 	if (t.name) return t.name;
@@ -404,6 +469,43 @@ export function isPointerToStruct(goType, checker = null, mod = null) {
 	return false;
 }
 
+// Slices, maps and pointers are reference values that an assignment through a
+// pointer replaces (a nil map becomes a new one, `*pp = q` repoints `p`),
+// unlike structs and arrays, whose pointer is the value's own reference.
+function isReplaceableRef(goType, checker) {
+	let t = goType;
+	if (t?.kind === "TypeName" && checker?.types?.has(t.name))
+		t = checker.types.get(t.name);
+	if (t?.kind === "named" && t.underlying) t = t.underlying;
+	return (
+		isSliceType(goType, checker) ||
+		isMapType(goType, checker) ||
+		t?.kind === "pointer" ||
+		t?.kind === "PointerType"
+	);
+}
+
+export function isScalarType(goType, checker = null, mod = null) {
+	if (!goType) return false;
+	// A slice or map is a pointee "scalar": the pointer to it is a
+	// box, so the pointee can be replaced (`*p = make(...)`).
+	if (isReplaceableRef(goType, checker)) return true;
+	if (
+		isStructType(goType, checker, mod) ||
+		isArrayType(goType, checker) ||
+		isMapType(goType, checker) ||
+		isFuncType(goType, checker) ||
+		isComplex(goType)
+	) {
+		return false;
+	}
+	const wType = toWasmType(goType, checker, mod);
+	if (typeof wType === "object" && wType !== null && wType.kind === "ref") {
+		return false;
+	}
+	return true;
+}
+
 export function isSliceType(goType, checker = null) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -413,9 +515,79 @@ export function isSliceType(goType, checker = null) {
 	if (goType.kind === "named" && goType.underlying) {
 		return isSliceType(goType.underlying, checker);
 	}
+	if (goType.kind === "named" && !goType.underlying) {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved && resolved !== goType) return isSliceType(resolved, checker);
+	}
 	return goType.kind === "slice" || goType.kind === "SliceType";
 }
 
+// Element kinds whose slices share one WebAssembly representation (a slice of
+// i32), so `[]bool`, `[]byte` and `[]rune` cannot be told apart by `ref.test`.
+const TAGGED_SLICE_ELEMS = new Set([
+	"bool",
+	"int8",
+	"int16",
+	"int32",
+	"uint8",
+	"uint16",
+	"uint32",
+	"byte",
+	"rune",
+]);
+
+// True for a defined slice type or a slice of booleans or integers of at
+// most 32 bits.  In an
+// interface such a value carries a per-Go-type tag (see getTaggedSliceType).
+export function isTaggedSliceType(goType, checker = null) {
+	if (!isSliceType(goType, checker)) return false;
+	// A defined slice type (`type S []int`) is tagged whatever its element, so
+	// `case S` does not match an unnamed `[]int`.
+	const declared =
+		goType.kind === "TypeName" || goType.kind === "Ident"
+			? (checker?.types?.get(goType.name) ?? goType)
+			: goType;
+	if (declared?.kind === "named") return true;
+	let elem = getSliceElemType(goType, checker);
+	// A source-level element (`uint8` in a case list) is a TypeName node.
+	for (let i = 0; i < 16 && elem; i++) {
+		if (elem.kind === "named")
+			elem = elem.underlying ?? checker?.types?.get(elem.name);
+		else if (elem.kind === "TypeName" || elem.kind === "Ident")
+			elem = checker?.types?.get(elem.name) ?? {
+				kind: "basic",
+				name: elem.name,
+			};
+		else break;
+	}
+	return elem?.kind === "basic" && TAGGED_SLICE_ELEMS.has(elem.name);
+}
+
+export function getSliceElemType(t, checker = null) {
+	if (!t) return null;
+	if (t.elem) return t.elem;
+	if (t.underlying?.elem) return t.underlying.elem;
+	if (t.name && checker?.types?.has(t.name)) {
+		const resolved = checker.types.get(t.name);
+		return getSliceElemType(resolved, checker);
+	}
+	return null;
+}
+
+// `[]rune` / `[]int32` (also through named types): the target of `[]rune(s)`.
+export function isRuneSlice(goType, checker = null) {
+	if (!isSliceType(goType, checker)) return false;
+	let t = goType;
+	while (t && !t.elem) {
+		if (t.kind === "named") t = t.underlying;
+		else if (t.kind === "TypeName" || t.kind === "Ident")
+			t = checker?.types?.get(t.name);
+		else return false;
+	}
+	const name = t?.elem?.name;
+	return name === "rune" || name === "int32";
+}
+
 // `gofront/shared` linear-memory buffer: returns the SHARED_KINDS entry
 // (elem, ctor, bytes, key) or null.
 export function getSharedInfo(goType, checker = null) {
@@ -451,6 +623,10 @@ export function isMapType(goType, checker = null) {
 	if (goType.kind === "named" && goType.underlying) {
 		return isMapType(goType.underlying, checker);
 	}
+	if (goType.kind === "named" && !goType.underlying) {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved && resolved !== goType) return isMapType(resolved, checker);
+	}
 	return goType.kind === "map" || goType.kind === "MapType";
 }
 
@@ -464,6 +640,11 @@ export function getMapKeyValTypes(goType, checker = null) {
 	if (goType.kind === "named" && goType.underlying) {
 		return getMapKeyValTypes(goType.underlying, checker);
 	}
+	if (goType.kind === "named" && !goType.underlying) {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved && resolved !== goType)
+			return getMapKeyValTypes(resolved, checker);
+	}
 	if (goType.kind === "map" || goType.kind === "MapType") {
 		const key = goType.key ?? goType.keyType;
 		const val =
@@ -483,6 +664,10 @@ export function isStringType(goType, checker = null) {
 	if (goType.kind === "named") {
 		if (goType.name === "string") return true;
 		if (goType.underlying) return isStringType(goType.underlying, checker);
+		// A bare `{ kind: "named", name }` (interface candidates) resolves by name.
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved && resolved !== goType && resolved.kind === "named")
+			return isStringType(resolved, checker);
 	}
 	if (goType.kind === "basic") return goType.name === "string";
 	if (goType.kind === "untyped") return goType.base === "string";
@@ -528,6 +713,14 @@ export function isInterfaceType(goType, checker = null) {
 	return false;
 }
 
+// `bool`, including the untyped boolean of a constant (`const ok = true`).
+export function isBoolGoType(goType) {
+	return (
+		goType?.name === "bool" ||
+		(goType?.kind === "untyped" && goType.base === "bool")
+	);
+}
+
 // The built-in `error` interface (checker ERROR type or its name).
 export function isErrorType(goType) {
 	if (!goType) return false;
@@ -593,6 +786,33 @@ export function isSigned(goType) {
 	return true;
 }
 
+// How a builtin `print`/`println` operand is handed to the host.  The host
+// prints an i32 or i64 as signed, so a uint32 widens to i64 and a uint64 uses
+// its own unsigned import (`wType` "u64").
+export function printOperandKind(arg, checker) {
+	const isBool =
+		isBoolGoType(arg._type) ||
+		_namedBasic(arg._type) === "bool" ||
+		(arg.kind === "BasicLit" && arg.litKind === "BOOL");
+	let wType = toWasmType(arg._type, checker);
+	let widen = false;
+	if (!isBool && (wType === "i32" || wType === "i64") && !isSigned(arg._type)) {
+		if (wType === "i64") wType = "u64";
+		else if (_namedBasic(arg._type) === "uint32") {
+			wType = "i64";
+			widen = true;
+		}
+	}
+	return { wType, isBool, widen };
+}
+
+function _namedBasic(t) {
+	while (t && (t.kind === "named" || t.kind === "TypeName") && t.underlying) {
+		t = t.underlying;
+	}
+	return t?.name;
+}
+
 export function isFloat(goType) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -639,7 +859,9 @@ export function getFuncSignature(goType, checker = null) {
 		goType.kind === "FuncLit" ||
 		goType.kind === "FuncDecl"
 	) {
-		const params = (goType.params ?? []).map((p) => p.type ?? p);
+		const params = (goType.params ?? []).map((p) =>
+			p.variadic ? { kind: "SliceType", elem: p.type } : (p.type ?? p),
+		);
 		const returns = [];
 		if (goType.returnType) {
 			if (
@@ -672,11 +894,22 @@ export function getFuncSignature(goType, checker = null) {
 				returns.push(r);
 			}
 		}
-		return { params: goType.params ?? [], returns };
+		return {
+			params: variadicAsSlice(goType.params ?? [], goType.variadic),
+			returns,
+		};
 	}
 	return { params: [], returns: [] };
 }
 
+// Checker func types keep a variadic parameter's element type; in WASM the
+// parameter is a slice (see variadic.js).
+export function variadicAsSlice(params, variadic) {
+	if (!variadic || params.length === 0) return params;
+	const last = params[params.length - 1];
+	return [...params.slice(0, -1), { kind: "slice", elem: last }];
+}
+
 export function isUnhashableGoType(goType, checker = null, seen = new Set()) {
 	if (!goType) return false;
 	if (seen.has(goType)) return false;

package/src/backend/wasm/variadic.js

@@ -0,0 +1,93 @@
+// src/backend/wasm/variadic.js
+// WASM has no rest parameters.  A variadic `xs ...T` becomes an ordinary
+// `[]T` parameter, and every call to a GoFront function, method or closure
+// packs its trailing arguments into a `[]T` literal (`f(s...)` passes `s`
+// through).  Emitter-backed stdlib calls keep their raw arguments.  Runs
+// after monomorphisation, so callee types are concrete, on the WASM
+// pipeline's own copy of the programs.
+
+import { typeToTypeNode } from "./monomorph.js";
+
+function variadicFuncType(t) {
+	const fn = t?.kind === "named" ? t.underlying : t;
+	return fn?.kind === "func" && fn.variadic ? fn : null;
+}
+
+// A call of a package member or a method of an emitter-backed type: those
+// emitters take the arguments unpacked.  Emitter types are the dotted names;
+// GoFront and Go-source types are not.
+function isStdlibCall(call) {
+	const f = call.func;
+	if (f?.kind !== "SelectorExpr") return false;
+	let recv = f.expr?._type;
+	if (recv?.kind === "namespace") return true;
+	if (recv?.kind === "pointer") recv = recv.base;
+	return typeof recv?.name === "string" && recv.name.includes(".");
+}
+
+function packCallArgs(call) {
+	if (call._multiForward || isStdlibCall(call)) return false;
+	const fn = variadicFuncType(call.func?._type);
+	if (!fn) return false;
+	const n = fn.params.length;
+	const args = call.args ?? [];
+	if (args.length === n && args[n - 1]?._spread) {
+		args[n - 1]._spread = false;
+		return true;
+	}
+	if (args.length < n - 1) return false;
+	const elem = fn.params[n - 1];
+	const sliceType = { kind: "slice", elem };
+	// No variadic arguments: the parameter is the nil slice, as in Go.
+	const rest = args.slice(n - 1);
+	const packed =
+		rest.length === 0
+			? {
+					kind: "TypeConversion",
+					targetType: sliceType,
+					expr: { kind: "Ident", name: "nil" },
+					_type: sliceType,
+					_line: call._line,
+					_col: call._col,
+				}
+			: null;
+	call.args = [
+		...args.slice(0, n - 1),
+		packed ?? {
+			kind: "CompositeLit",
+			typeExpr: { kind: "SliceType", elem: typeToTypeNode(elem) },
+			elems: args.slice(n - 1),
+			_type: sliceType,
+			_line: call._line,
+			_col: call._col,
+		},
+	];
+	return true;
+}
+
+function sliceVariadicParam(params) {
+	const last = params?.[params.length - 1];
+	if (!last?.variadic) return false;
+	last.type = { kind: "SliceType", elem: last.type };
+	last.variadic = false;
+	last._variadic = true; // the JS facade keeps a rest parameter
+	return true;
+}
+
+/** Rewrites variadic declarations and calls in place; true if anything changed. */
+export function desugarVariadics(node) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) {
+		let changed = false;
+		for (const n of node) changed = desugarVariadics(n) || changed;
+		return changed;
+	}
+	let changed = false;
+	if (Array.isArray(node.params)) changed = sliceVariadicParam(node.params);
+	if (node.kind === "CallExpr") changed = packCallArgs(node) || changed;
+	for (const key of Object.keys(node)) {
+		if (key.charCodeAt(0) === 95) continue; // "_" side tables
+		changed = desugarVariadics(node[key]) || changed;
+	}
+	return changed;
+}

package/src/backend/wasm/wat.js

@@ -8,7 +8,13 @@ function formatValType(t) {
 		if (t.kind === "ref") {
 			const nullStr = t.nullable ? "null " : "";
 			const target =
-				t.typeIndex !== undefined ? `$t${t.typeIndex}` : (t.heapType ?? "any");
+				t.typeName !== undefined
+					? t.typeName.startsWith("$")
+						? t.typeName
+						: `$${t.typeName}`
+					: t.typeIndex !== undefined
+						? `$t${t.typeIndex}`
+						: (t.heapType ?? "any");
 			return `(ref ${nullStr}${target})`;
 		}
 	}
@@ -16,7 +22,11 @@ function formatValType(t) {
 }
 
 function formatTypeEntry(t, id) {
-	const typeId = id !== undefined ? ` $t${id}` : "";
+	const typeId = t.name
+		? ` ${t.name.startsWith("$") ? t.name : `$${t.name}`}`
+		: id !== undefined
+			? ` $t${id}`
+			: "";
 	if (t.form === "rec") {
 		const inners = t.types
 			.map(
@@ -26,6 +36,7 @@ function formatTypeEntry(t, id) {
 			.join("\n");
 		return `(rec\n${inners}\n  )`;
 	}
+	let body;
 	if (t.form === "struct") {
 		const fields = (t.fields ?? [])
 			.map((f) => {
@@ -33,19 +44,29 @@ function formatTypeEntry(t, id) {
 				return f.mutable ? `(field (mut ${inner}))` : `(field ${inner})`;
 			})
 			.join(" ");
-		return `(type${typeId} (struct ${fields}))`;
-	}
-	if (t.form === "array") {
+		body = fields ? `(struct ${fields})` : `(struct)`;
+	} else if (t.form === "array") {
 		const inner = formatValType(t.elemType ?? t.type);
 		const field = t.mutable ? `(mut ${inner})` : inner;
-		return `(type${typeId} (array ${field}))`;
+		body = `(array ${field})`;
+	} else {
+		// func
+		const params = (t.params ?? []).map(formatValType).join(" ");
+		const results = (t.results ?? []).map(formatValType).join(" ");
+		const paramStr = params ? ` (param ${params})` : "";
+		const resultStr = results ? ` (result ${results})` : "";
+		body = `(func${paramStr}${resultStr})`;
+	}
+
+	if (t.sub) {
+		const superStr = t.superType
+			? ` ${t.superType.startsWith("$") ? t.superType : `$${t.superType}`}`
+			: t.superTypeIndex !== undefined
+				? ` $t${t.superTypeIndex}`
+				: "";
+		return `(type${typeId} (sub${superStr} ${body}))`;
 	}
-	// func
-	const params = (t.params ?? []).map(formatValType).join(" ");
-	const results = (t.results ?? []).map(formatValType).join(" ");
-	const paramStr = params ? ` (param ${params})` : "";
-	const resultStr = results ? ` (result ${results})` : "";
-	return `(type${typeId} (func${paramStr}${resultStr}))`;
+	return `(type${typeId} ${body})`;
 }
 
 function formatInstruction(inst) {
@@ -56,11 +77,13 @@ function formatInstruction(inst) {
 		case "loop":
 		case "if": {
 			const bt = inst.blockType ?? inst.resultType;
+			if (typeof bt === "number") return `${op} (type $t${bt})`;
 			const res = bt && bt !== "void" ? ` (result ${formatValType(bt)})` : "";
 			return `${op}${res}`;
 		}
 		case "br":
 		case "br_if":
+		case "br_on_null":
 			return `${op} ${inst.depth ?? inst.index ?? 0}`;
 		case "br_table": {
 			const targets = (inst.targets ?? []).join(" ");
@@ -73,7 +96,7 @@ function formatInstruction(inst) {
 			return `${op} (type $t${inst.typeIndex ?? 0})`;
 		case "call_ref":
 		case "return_call_ref":
-			return `${op} (type $t${inst.typeIndex ?? 0})`;
+			return `${op} ${inst.typeName ? (inst.typeName.startsWith("$") ? inst.typeName : `$${inst.typeName}`) : `$t${inst.typeIndex ?? 0}`}`;
 		case "ref.func":
 			return `ref.func ${inst.funcIndex ?? inst.index ?? 0}`;
 		case "local.get":
@@ -169,12 +192,12 @@ function formatInstruction(inst) {
 			return `${op}${res}${catches ? ` ${catches}` : ""}`;
 		}
 		case "struct.new":
-			return `struct.new ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0}`;
+			return `struct.new ${inst.typeName ? (inst.typeName.startsWith("$") ? inst.typeName : `$${inst.typeName}`) : inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0}`;
 		case "struct.get":
 		case "struct.get_s":
 		case "struct.get_u":
 		case "struct.set":
-			return `${op} ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0} ${inst.fieldIndex ?? 0}`;
+			return `${op} ${inst.typeName ? (inst.typeName.startsWith("$") ? inst.typeName : `$${inst.typeName}`) : inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0} ${inst.fieldIndex ?? 0}`;
 		case "array.new":
 		case "array.new_default":
 		case "array.get":
@@ -193,11 +216,15 @@ function formatInstruction(inst) {
 		case "ref.cast":
 		case "ref.cast_null": {
 			const ht =
-				inst.typeIndex !== undefined
-					? `$t${inst.typeIndex}`
-					: inst.heapType !== undefined
-						? String(inst.heapType)
-						: 0;
+				inst.typeName !== undefined
+					? inst.typeName.startsWith("$")
+						? inst.typeName
+						: `$${inst.typeName}`
+					: inst.typeIndex !== undefined
+						? `$t${inst.typeIndex}`
+						: inst.heapType !== undefined
+							? String(inst.heapType)
+							: 0;
 			return `${op} ${ht}`;
 		}
 		case "any.convert_extern":