gofront 1.3.12 → 1.5.1

package/src/backend/wasm/types.js

@@ -0,0 +1,420 @@
+// src/backend/wasm/types.js
+// Maps GoFront types to WasmGC types and manages type registry.
+
+// `*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 (isTestingT(goType)) return "externref";
+
+	// Pointer AST nodes
+	if (goType.kind === "PointerType") {
+		return toWasmType({ kind: "pointer", base: goType.base }, checker, mod);
+	}
+	if (goType.kind === "StarExpr") {
+		return toWasmType(
+			{ kind: "pointer", base: goType.expr ?? goType.operand },
+			checker,
+			mod,
+		);
+	}
+
+	// Slice and Array AST nodes
+	if (goType.kind === "SliceType") {
+		return toWasmType({ kind: "slice", elem: goType.elem }, checker, mod);
+	}
+	if (goType.kind === "ArrayType") {
+		return toWasmType({ kind: "array", elem: goType.elem }, checker, mod);
+	}
+
+	// TypeName AST node
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		if (mod?.getStructType(goType.name)) {
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: mod.getStructType(goType.name).typeIndex,
+			};
+		}
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) {
+			return toWasmType(resolved, checker, mod);
+		}
+		return toWasmType({ kind: "basic", name: goType.name }, checker, mod);
+	}
+
+	// Unwrap named types
+	if (goType.kind === "named") {
+		if (mod?.getStructType(goType.name)) {
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: mod.getStructType(goType.name).typeIndex,
+			};
+		}
+		if (goType.underlying) {
+			return toWasmType(goType.underlying, checker, mod);
+		}
+	}
+
+	// Untyped constants
+	if (goType.kind === "untyped") {
+		switch (goType.base) {
+			case "int":
+				return "i64"; // Default Go integer is int (i64 in WASM subset)
+			case "float64":
+				return "f64";
+			case "string":
+				return "externref";
+			case "bool":
+				return "i32";
+			default:
+				return "i64";
+		}
+	}
+
+	if (goType.kind === "basic") {
+		switch (goType.name) {
+			case "bool":
+			case "int8":
+			case "int16":
+			case "int32":
+			case "uint8":
+			case "uint16":
+			case "uint32":
+			case "byte":
+			case "rune":
+				return "i32";
+
+			case "int":
+			case "uint":
+			case "int64":
+			case "uint64":
+			case "uintptr":
+				return "i64";
+
+			case "float32":
+				return "f32";
+
+			case "float64":
+				return "f64";
+
+			case "string":
+				return "externref";
+
+			case "any":
+				return "anyref";
+
+			case "void":
+				return null;
+
+			default:
+				return "i64";
+		}
+	}
+
+	if (goType.kind === "pointer") {
+		// Struct pointer or boxed scalar
+		if (goType.base) {
+			const baseWType = toWasmType(goType.base, checker, mod);
+			if (
+				typeof baseWType === "object" &&
+				baseWType !== null &&
+				baseWType.kind === "ref"
+			) {
+				return baseWType;
+			}
+			if (mod?.getBoxType) {
+				const box = mod.getBoxType(goType.base);
+				if (box)
+					return { kind: "ref", nullable: true, typeIndex: box.typeIndex };
+			}
+		}
+		return { kind: "ref", nullable: true, heapType: "any" };
+	}
+
+	if (goType.kind === "slice") {
+		if (mod?.getSliceType && goType.elem) {
+			const sliceInfo = mod.getSliceType(goType.elem);
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: sliceInfo.typeIndex,
+			};
+		}
+		return { kind: "ref", nullable: true, heapType: "struct" };
+	}
+
+	if (goType.kind === "array") {
+		if (mod?.getArrayType && goType.elem) {
+			const arrInfo = mod.getArrayType(goType.elem);
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: arrInfo.typeIndex,
+			};
+		}
+		return { kind: "ref", nullable: true, heapType: "array" };
+	}
+
+	if (goType.kind === "struct") {
+		if (goType.name && mod?.getStructType(goType.name)) {
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: mod.getStructType(goType.name).typeIndex,
+			};
+		}
+		return { kind: "ref", nullable: true, heapType: "struct" };
+	}
+
+	if (isFuncType(goType, checker)) {
+		if (mod) {
+			const closureInfo = mod.getClosureType(goType);
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: closureInfo.typeIndex,
+			};
+		}
+		return "funcref";
+	}
+
+	if (goType.kind === "interface" || goType.kind === "InterfaceType") {
+		return "anyref";
+	}
+
+	return "i32";
+}
+
+export function isStructType(goType, checker = null, mod = null) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		if (mod?.getStructType?.(goType.name)) return true;
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isStructType(resolved, checker, mod);
+	}
+	if (goType.kind === "named") {
+		if (mod?.getStructType?.(goType.name)) return true;
+		if (goType.underlying) return isStructType(goType.underlying, checker, mod);
+	}
+	return goType.kind === "struct" || goType.kind === "StructType";
+}
+
+export function isPointerToStruct(goType, checker = null, mod = null) {
+	if (!goType) return false;
+	if (goType.kind === "PointerType" || goType.kind === "pointer") {
+		return isStructType(goType.base, checker, mod);
+	}
+	if (goType.kind === "StarExpr") {
+		return isStructType(goType.expr ?? goType.operand, checker, mod);
+	}
+	return false;
+}
+
+export function isSliceType(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isSliceType(resolved, checker);
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isSliceType(goType.underlying, checker);
+	}
+	return goType.kind === "slice" || goType.kind === "SliceType";
+}
+
+export function isArrayType(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isArrayType(resolved, checker);
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isArrayType(goType.underlying, checker);
+	}
+	return goType.kind === "array" || goType.kind === "ArrayType";
+}
+
+export function isStringType(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isStringType(resolved, checker);
+		return goType.name === "string";
+	}
+	if (goType.kind === "named") {
+		if (goType.name === "string") return true;
+		if (goType.underlying) return isStringType(goType.underlying, checker);
+	}
+	if (goType.kind === "basic") return goType.name === "string";
+	if (goType.kind === "untyped") return goType.base === "string";
+	return false;
+}
+
+export function isAnyType(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isAnyType(resolved, checker);
+		return goType.name === "any" || goType.name === "interface{}";
+	}
+	if (goType.kind === "named") {
+		if (goType.name === "any" || goType.name === "interface{}") return true;
+		if (goType.underlying) return isAnyType(goType.underlying, checker);
+	}
+	if (goType.kind === "basic") return goType.name === "any";
+	if (goType.kind === "interface") return true;
+	return false;
+}
+
+export function isNarrowInt(goType) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		return isNarrowInt({ kind: "basic", name: goType.name });
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isNarrowInt(goType.underlying);
+	}
+	if (goType.kind === "basic") {
+		switch (goType.name) {
+			case "int8":
+			case "int16":
+			case "uint8":
+			case "uint16":
+			case "byte":
+				return true;
+		}
+	}
+	return false;
+}
+
+export function isSigned(goType) {
+	if (!goType) return true;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		return isSigned({ kind: "basic", name: goType.name });
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isSigned(goType.underlying);
+	}
+	if (goType.kind === "basic") {
+		return !goType.name.startsWith("uint") && goType.name !== "byte";
+	}
+	return true;
+}
+
+export function isFloat(goType) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		return isFloat({ kind: "basic", name: goType.name });
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isFloat(goType.underlying);
+	}
+	if (goType.kind === "untyped") return goType.base === "float64";
+	return (
+		goType.kind === "basic" &&
+		(goType.name === "float32" || goType.name === "float64")
+	);
+}
+
+export function isInt(goType) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		return isInt({ kind: "basic", name: goType.name });
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isInt(goType.underlying);
+	}
+	if (goType.kind === "untyped") return goType.base === "int";
+	if (goType.kind === "basic") {
+		return (
+			goType.name.startsWith("int") ||
+			goType.name.startsWith("uint") ||
+			goType.name === "byte" ||
+			goType.name === "rune" ||
+			goType.name === "uintptr"
+		);
+	}
+	return false;
+}
+
+export function isFuncType(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isFuncType(resolved, checker);
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isFuncType(goType.underlying, checker);
+	}
+	return (
+		goType.kind === "func" ||
+		goType.kind === "FuncType" ||
+		goType.kind === "FuncLit" ||
+		goType.kind === "FuncDecl"
+	);
+}
+
+export function getFuncSignature(goType, checker = null) {
+	if (!goType) return { params: [], returns: [] };
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return getFuncSignature(resolved, checker);
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return getFuncSignature(goType.underlying, checker);
+	}
+	if (
+		goType.kind === "FuncType" ||
+		goType.kind === "FuncLit" ||
+		goType.kind === "FuncDecl"
+	) {
+		const params = (goType.params ?? []).map((p) => p.type ?? p);
+		const returns = [];
+		if (goType.returnType) {
+			if (
+				goType.returnType.kind === "TupleType" ||
+				goType.returnType.kind === "tuple"
+			) {
+				returns.push(...(goType.returnType.types ?? []));
+			} else {
+				returns.push(goType.returnType);
+			}
+		} else if (goType.returns) {
+			for (const r of goType.returns) {
+				if ((r?.kind === "tuple" || r?.kind === "TupleType") && r.types) {
+					returns.push(...r.types);
+				} else {
+					returns.push(r);
+				}
+			}
+		}
+		return { params, returns };
+	}
+	if (goType.kind === "func") {
+		const rawReturns =
+			goType.returns ?? (goType.returnType ? [goType.returnType] : []);
+		const returns = [];
+		for (const r of rawReturns) {
+			if ((r?.kind === "tuple" || r?.kind === "TupleType") && r.types) {
+				returns.push(...r.types);
+			} else {
+				returns.push(r);
+			}
+		}
+		return { params: goType.params ?? [], returns };
+	}
+	return { params: [], returns: [] };
+}

package/src/backend/wasm/wat.js

@@ -0,0 +1,255 @@
+// src/backend/wasm/wat.js
+// Emits WebAssembly Text (WAT) format from Module IR.
+
+function formatValType(t) {
+	if (typeof t === "string") return t;
+	if (typeof t === "number") return `(type ${t})`;
+	if (typeof t === "object" && t !== null) {
+		if (t.kind === "ref") {
+			const nullStr = t.nullable ? "null " : "";
+			const target =
+				t.typeIndex !== undefined ? `$t${t.typeIndex}` : (t.heapType ?? "any");
+			return `(ref ${nullStr}${target})`;
+		}
+	}
+	return String(t);
+}
+
+function formatTypeEntry(t, id) {
+	const typeId = id !== undefined ? ` $t${id}` : "";
+	if (t.form === "rec") {
+		const inners = t.types
+			.map(
+				(sub, i) =>
+					`    ${formatTypeEntry(sub, typeof id === "number" ? id + i : `${id}_${i}`)}`,
+			)
+			.join("\n");
+		return `(rec\n${inners}\n  )`;
+	}
+	if (t.form === "struct") {
+		const fields = (t.fields ?? [])
+			.map((f) => {
+				const inner = formatValType(f.type);
+				return f.mutable ? `(field (mut ${inner}))` : `(field ${inner})`;
+			})
+			.join(" ");
+		return `(type${typeId} (struct ${fields}))`;
+	}
+	if (t.form === "array") {
+		const inner = formatValType(t.elemType ?? t.type);
+		const field = t.mutable ? `(mut ${inner})` : inner;
+		return `(type${typeId} (array ${field}))`;
+	}
+	// 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}))`;
+}
+
+function formatInstruction(inst) {
+	if (typeof inst === "string") return inst;
+	const { op } = inst;
+	switch (op) {
+		case "block":
+		case "loop":
+		case "if": {
+			const bt = inst.blockType ?? inst.resultType;
+			const res = bt && bt !== "void" ? ` (result ${formatValType(bt)})` : "";
+			return `${op}${res}`;
+		}
+		case "br":
+		case "br_if":
+			return `${op} ${inst.depth ?? inst.index ?? 0}`;
+		case "br_table": {
+			const targets = (inst.targets ?? []).join(" ");
+			return `${op} ${targets} ${inst.defaultTarget ?? 0}`;
+		}
+		case "call":
+		case "return_call":
+			return `${op} ${inst.funcIndex ?? inst.index ?? 0}`;
+		case "call_indirect":
+			return `${op} (type $t${inst.typeIndex ?? 0})`;
+		case "call_ref":
+		case "return_call_ref":
+			return `${op} (type $t${inst.typeIndex ?? 0})`;
+		case "ref.func":
+			return `ref.func ${inst.funcIndex ?? inst.index ?? 0}`;
+		case "local.get":
+		case "local.set":
+		case "local.tee":
+			return `${op} ${inst.localIndex ?? inst.index ?? 0}`;
+		case "global.get":
+		case "global.set":
+			return `${op} ${inst.globalIndex ?? inst.index ?? 0}`;
+		case "i32.const":
+		case "i64.const":
+			return `${op} ${inst.value ?? 0}`;
+		case "f32.const":
+		case "f64.const": {
+			const v = inst.value ?? 0;
+			if (Number.isNaN(v)) return `${op} nan`;
+			if (v === Infinity) return `${op} inf`;
+			if (v === -Infinity) return `${op} -inf`;
+			return `${op} ${v}`;
+		}
+		case "throw":
+			return `${op} ${inst.tagIndex ?? inst.index ?? 0}`;
+		case "struct.new":
+			return `struct.new ${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}`;
+		case "array.new":
+		case "array.new_default":
+		case "array.get":
+		case "array.get_s":
+		case "array.get_u":
+		case "array.set":
+			return `${op} ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0}`;
+		case "array.new_fixed":
+			return `${op} ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0} ${inst.size ?? inst.count ?? 0}`;
+		case "array.copy":
+			return `${op} ${inst.typeIndexDst !== undefined ? `$t${inst.typeIndexDst}` : `$t${inst.typeIndex ?? 0}`} ${inst.typeIndexSrc !== undefined ? `$t${inst.typeIndexSrc}` : `$t${inst.typeIndex ?? 0}`}`;
+		case "array.len":
+			return "array.len";
+		case "ref.test":
+		case "ref.test_null":
+		case "ref.cast":
+		case "ref.cast_null":
+			return `${op} ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0}`;
+		case "any.convert_extern":
+		case "extern.convert_any":
+			return op;
+		default:
+			return op;
+	}
+}
+
+export function emitWat(mod) {
+	const lines = ["(module"];
+
+	// 1. Types
+	if (mod.types && mod.types.length > 0) {
+		let typeIdx = 0;
+		for (let i = 0; i < mod.types.length; i++) {
+			const entry = mod.types[i];
+			lines.push(`  ${formatTypeEntry(entry, typeIdx)}`);
+			if (entry.form === "rec") {
+				typeIdx += entry.types.length;
+			} else {
+				typeIdx += 1;
+			}
+		}
+	}
+
+	// 2. Imports
+	if (mod.imports && mod.imports.length > 0) {
+		for (const imp of mod.imports) {
+			const desc =
+				imp.kind === "func"
+					? `(func (type $t${imp.typeIndex ?? 0}))`
+					: imp.kind === "tag"
+						? `(tag (type $t${imp.typeIndex ?? 0}))`
+						: `(${imp.kind})`;
+			lines.push(`  (import "${imp.module}" "${imp.name}" ${desc})`);
+		}
+	}
+
+	// 3. Tags
+	if (mod.tags && mod.tags.length > 0) {
+		for (let i = 0; i < mod.tags.length; i++) {
+			lines.push(`  (tag $tag${i} (type $t${mod.tags[i].typeIndex ?? 0}))`);
+		}
+	}
+
+	// 4. Globals
+	if (mod.globals && mod.globals.length > 0) {
+		for (let i = 0; i < mod.globals.length; i++) {
+			const g = mod.globals[i];
+			const t = formatValType(g.type);
+			const typeStr = g.mutable ? `(mut ${t})` : t;
+			const initStr = (g.init ?? [{ op: "i32.const", value: 0 }])
+				.map(formatInstruction)
+				.join(" ");
+			lines.push(`  (global $g${i} ${typeStr} ${initStr})`);
+		}
+	}
+
+	// 5. Elements (declarative for ref.func)
+	if (mod.elements && mod.elements.length > 0) {
+		lines.push(
+			`  (elem declare func ${mod.elements.map((idx) => `$f${idx}`).join(" ")})`,
+		);
+	}
+
+	// Map exports by kind & index
+	const exportsByFunc = new Map();
+	for (const exp of mod.exports ?? []) {
+		if (exp.kind === "func") {
+			if (!exportsByFunc.has(exp.index)) exportsByFunc.set(exp.index, []);
+			exportsByFunc.get(exp.index).push(exp.name);
+		}
+	}
+
+	// 5. Functions
+	if (mod.funcs && mod.funcs.length > 0) {
+		const importFuncCount = (mod.imports ?? []).filter(
+			(i) => i.kind === "func",
+		).length;
+		// Type indices count every member of a rec group, not the group entry.
+		const flatTypes = (mod.types ?? []).flatMap((t) =>
+			t.form === "rec" ? t.types : [t],
+		);
+
+		for (let i = 0; i < mod.funcs.length; i++) {
+			const fn = mod.funcs[i];
+			const globalFuncIdx = importFuncCount + i;
+			const expNames = exportsByFunc.get(globalFuncIdx) ?? [];
+			const expStr = expNames.map((n) => ` (export "${n}")`).join("");
+
+			const typeEntry = flatTypes[fn.typeIndex] ?? null;
+			let sigStr = ` (type $t${fn.typeIndex ?? 0})`;
+			if (typeEntry && typeEntry.form === "func") {
+				const params = (typeEntry.params ?? []).map(formatValType).join(" ");
+				const results = (typeEntry.results ?? []).map(formatValType).join(" ");
+				if (params) sigStr += ` (param ${params})`;
+				if (results) sigStr += ` (result ${results})`;
+			}
+
+			lines.push(`  (func $f${globalFuncIdx}${expStr}${sigStr}`);
+
+			// Locals
+			if (fn.locals && fn.locals.length > 0) {
+				const locTypes = fn.locals.map((l) =>
+					l && typeof l === "object" && "type" in l && !l.kind ? l.type : l,
+				);
+				lines.push(`    (local ${locTypes.map(formatValType).join(" ")})`);
+			}
+
+			// Body instructions
+			for (const inst of fn.body ?? []) {
+				lines.push(`    ${formatInstruction(inst)}`);
+			}
+			lines.push("  )");
+		}
+	}
+
+	// 6. Remaining exports (e.g. tags, globals, memories)
+	for (const exp of mod.exports ?? []) {
+		if (exp.kind !== "func") {
+			lines.push(`  (export "${exp.name}" (${exp.kind} ${exp.index}))`);
+		}
+	}
+
+	// 7. Start function
+	if (typeof mod.start === "number") {
+		lines.push(`  (start $f${mod.start})`);
+	}
+
+	lines.push(")");
+	return `${lines.join("\n")}\n`;
+}