gofront 1.5.1 → 1.6.1

package/src/backend/wasm/types.js

@@ -1,6 +1,11 @@
 // src/backend/wasm/types.js
 // Maps GoFront types to WasmGC types and manages type registry.
 
+import { SHARED_KINDS } from "../../typechecker/stdlib/shared.js";
+
+// 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) {
@@ -16,6 +21,22 @@ export function isTestingT(goType) {
 
 export function toWasmType(goType, checker = null, mod = null) {
 	if (!goType) return "i32";
+	if (typeof goType === "string") {
+		if (
+			goType === "i32" ||
+			goType === "i64" ||
+			goType === "f32" ||
+			goType === "f64" ||
+			goType === "anyref" ||
+			goType === "externref" ||
+			goType === "funcref"
+		) {
+			return goType;
+		}
+	}
+	if (typeof goType === "object" && goType.kind === "ref") {
+		return goType;
+	}
 	if (isTestingT(goType)) return "externref";
 
 	// Pointer AST nodes
@@ -30,13 +51,20 @@ export function toWasmType(goType, checker = null, mod = null) {
 		);
 	}
 
-	// Slice and Array AST nodes
+	// Slice, Array, and Map 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);
 	}
+	if (goType.kind === "MapType") {
+		return toWasmType(
+			{ kind: "map", key: goType.key, value: goType.value ?? goType.elem },
+			checker,
+			mod,
+		);
+	}
 
 	// TypeName AST node
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -114,6 +142,7 @@ export function toWasmType(goType, checker = null, mod = null) {
 				return "externref";
 
 			case "any":
+			case "error":
 				return "anyref";
 
 			case "void":
@@ -144,6 +173,16 @@ export function toWasmType(goType, checker = null, mod = null) {
 		return { kind: "ref", nullable: true, heapType: "any" };
 	}
 
+	if (goType.kind === "shared") {
+		if (mod?.getSharedType)
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: mod.getSharedType().typeIndex,
+			};
+		return { kind: "ref", nullable: true, heapType: "struct" };
+	}
+
 	if (goType.kind === "slice") {
 		if (mod?.getSliceType && goType.elem) {
 			const sliceInfo = mod.getSliceType(goType.elem);
@@ -168,7 +207,21 @@ export function toWasmType(goType, checker = null, mod = null) {
 		return { kind: "ref", nullable: true, heapType: "array" };
 	}
 
-	if (goType.kind === "struct") {
+	if (goType.kind === "map") {
+		const key = goType.key;
+		const val = goType.value ?? goType.elem;
+		if (mod?.getMapType && key && val) {
+			const mapInfo = mod.getMapType(key, val);
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: mapInfo.typeIndex,
+			};
+		}
+		return { kind: "ref", nullable: true, heapType: "struct" };
+	}
+
+	if (goType.kind === "struct" || goType.kind === "StructType") {
 		if (goType.name && mod?.getStructType(goType.name)) {
 			return {
 				kind: "ref",
@@ -176,6 +229,23 @@ export function toWasmType(goType, checker = null, mod = null) {
 				typeIndex: mod.getStructType(goType.name).typeIndex,
 			};
 		}
+		if (mod?.getAnonStructType && goType.fields) {
+			const rawFields = [];
+			if (goType.fields instanceof Map) {
+				for (const [k, v] of goType.fields.entries()) {
+					rawFields.push({ name: k, goType: v });
+				}
+			} else if (Array.isArray(goType.fields)) {
+				for (const f of goType.fields) {
+					const names = f.names ?? (f.name ? [f.name] : []);
+					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 };
+			}
+		}
 		return { kind: "ref", nullable: true, heapType: "struct" };
 	}
 
@@ -198,6 +268,96 @@ export function toWasmType(goType, checker = null, mod = null) {
 	return "i32";
 }
 
+export function getInterfaceMethodList(iface) {
+	if (!iface) return [];
+	if (iface.methods instanceof Map) {
+		return Array.from(iface.methods.entries()).map(([name, sig]) => ({
+			name,
+			params: (sig.params ?? []).map((p) => p.type ?? p),
+			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),
+			returns: m.returnType
+				? m.returnType.kind === "TupleType" || m.returnType.kind === "tuple"
+					? m.returnType.types
+					: [m.returnType]
+				: [],
+		}));
+	}
+	return [];
+}
+
+export function goTypeKey(t) {
+	if (!t) return "any";
+	if (typeof t === "string") {
+		if (t === "byte") return "uint8";
+		if (t === "rune") return "int32";
+		return t;
+	}
+	if (t.kind === "basic" || t.kind === "TypeName" || t.kind === "Ident") {
+		const name = t.name ?? "any";
+		if (name === "byte") return "uint8";
+		if (name === "rune") return "int32";
+		return name;
+	}
+	if (t.kind === "untyped") {
+		return t.base ?? "int";
+	}
+	if (t.kind === "pointer" || t.kind === "PointerType") {
+		return `ptr_${goTypeKey(t.base)}`;
+	}
+	if (t.kind === "StarExpr") {
+		return `ptr_${goTypeKey(t.expr ?? t.operand)}`;
+	}
+	if (t.kind === "slice" || t.kind === "SliceType") {
+		return `sl_${goTypeKey(t.elem)}`;
+	}
+	if (t.kind === "array" || t.kind === "ArrayType") {
+		const sz =
+			typeof t.size === "number" ? t.size : (t.size?.value ?? t.len ?? "");
+		return `arr_${sz}_${goTypeKey(t.elem)}`;
+	}
+	if (t.kind === "map" || t.kind === "MapType") {
+		return `map_${goTypeKey(t.key ?? t.keyType)}_${goTypeKey(t.value ?? t.val ?? t.elem ?? t.valueType ?? t.valType)}`;
+	}
+	if (t.kind === "struct" || t.kind === "StructType") {
+		if (t.name) return t.name;
+		const rawFields = [];
+		if (t.fields instanceof Map) {
+			for (const [k, v] of t.fields.entries())
+				rawFields.push(`${k}:${goTypeKey(v)}`);
+		} else if (Array.isArray(t.fields)) {
+			for (const f of t.fields) {
+				const names = f.names ?? (f.name ? [f.name] : []);
+				for (const n of names)
+					rawFields.push(`${n}:${goTypeKey(f.type ?? f.goType)}`);
+			}
+		}
+		return `struct_${rawFields.join("_")}`;
+	}
+	if (t.kind === "named") {
+		return t.name ?? (t.underlying ? goTypeKey(t.underlying) : "any");
+	}
+	if (t.name) return t.name;
+	return t.kind ?? "any";
+}
+
+export function anonIfaceName(iface, _checker = null, _mod = null) {
+	const methods = getInterfaceMethodList(iface);
+	methods.sort((a, b) => a.name.localeCompare(b.name));
+	const parts = methods.map((m) => {
+		const ps = m.params.map((p) => goTypeKey(p)).join("_");
+		const rs = m.returns.map((r) => goTypeKey(r)).join("_");
+		return `${m.name}_${ps}_${rs}`;
+	});
+	const key = parts.join("__").replace(/[^a-zA-Z0-9_]/g, "_");
+	return `anon_iface_${key}`;
+}
+
 export function isStructType(goType, checker = null, mod = null) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -235,6 +395,20 @@ export function isSliceType(goType, checker = null) {
 	return goType.kind === "slice" || goType.kind === "SliceType";
 }
 
+// `gofront/shared` linear-memory buffer: returns the SHARED_KINDS entry
+// (elem, ctor, bytes, key) or null.
+export function getSharedInfo(goType, checker = null) {
+	if (!goType) return null;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		return resolved ? getSharedInfo(resolved, checker) : null;
+	}
+	if (goType.kind === "named" && goType.underlying)
+		return getSharedInfo(goType.underlying, checker);
+	if (goType.kind !== "shared") return null;
+	return { name: goType.shared, ...SHARED_KINDS[goType.shared] };
+}
+
 export function isArrayType(goType, checker = null) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -247,6 +421,37 @@ export function isArrayType(goType, checker = null) {
 	return goType.kind === "array" || goType.kind === "ArrayType";
 }
 
+export function isMapType(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isMapType(resolved, checker);
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isMapType(goType.underlying, checker);
+	}
+	return goType.kind === "map" || goType.kind === "MapType";
+}
+
+// Returns `{ keyType, valType }` (Go types) for a map type, or nulls.
+export function getMapKeyValTypes(goType, checker = null) {
+	if (!goType) return { keyType: null, valType: null };
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return getMapKeyValTypes(resolved, checker);
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return getMapKeyValTypes(goType.underlying, checker);
+	}
+	if (goType.kind === "map" || goType.kind === "MapType") {
+		const key = goType.key ?? goType.keyType;
+		const val =
+			goType.value ?? goType.elem ?? goType.valueType ?? goType.valType;
+		return { keyType: key, valType: val };
+	}
+	return { keyType: null, valType: null };
+}
+
 export function isStringType(goType, checker = null) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -279,27 +484,80 @@ export function isAnyType(goType, checker = null) {
 	return false;
 }
 
-export function isNarrowInt(goType) {
+export function isInterfaceType(goType, checker = null) {
 	if (!goType) return false;
+	if (
+		goType.kind === "basic" &&
+		(goType.name === "any" || goType.name === "interface{}")
+	)
+		return true;
+	if (goType.kind === "interface" || goType.kind === "InterfaceType")
+		return true;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
-		return isNarrowInt({ kind: "basic", name: goType.name });
+		if (goType.name === "any" || goType.name === "interface{}") return true;
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isInterfaceType(resolved, checker);
 	}
-	if (goType.kind === "named" && goType.underlying) {
-		return isNarrowInt(goType.underlying);
+	if (goType.kind === "named") {
+		if (goType.name === "any" || goType.name === "interface{}") return true;
+		if (goType.underlying) return isInterfaceType(goType.underlying, checker);
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isInterfaceType(resolved, checker);
 	}
-	if (goType.kind === "basic") {
-		switch (goType.name) {
-			case "int8":
-			case "int16":
-			case "uint8":
-			case "uint16":
-			case "byte":
-				return true;
-		}
+	return false;
+}
+
+// The built-in `error` interface (checker ERROR type or its name).
+export function isErrorType(goType) {
+	if (!goType) return false;
+	if (goType.kind === "interface") return goType.name === "error";
+	if (
+		(goType.kind === "named" ||
+			goType.kind === "TypeName" ||
+			goType.kind === "Ident") &&
+		goType.name === "error"
+	) {
+		return true;
+	}
+	if (goType.kind === "named" && goType.underlying)
+		return isErrorType(goType.underlying);
+	return false;
+}
+
+export function isNonEmptyInterface(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.name === "any" || goType.name === "interface{}") return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isNonEmptyInterface(resolved, checker);
+	}
+	if (goType.kind === "named") {
+		if (goType.name === "any" || goType.name === "interface{}") return false;
+		if (goType.underlying)
+			return isNonEmptyInterface(goType.underlying, checker);
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isNonEmptyInterface(resolved, checker);
+	}
+	if (goType.kind === "interface" || goType.kind === "InterfaceType") {
+		if (goType.methods instanceof Map) return goType.methods.size > 0;
+		if (Array.isArray(goType.methods)) return goType.methods.length > 0;
+		if (goType.methods instanceof Set) return goType.methods.size > 0;
+		return false;
 	}
 	return false;
 }
 
+export function getReceiverTypeName(recvType, _node = null) {
+	if (recvType) {
+		let t = recvType;
+		while (t.kind === "pointer") t = t.base;
+		if (t.name) return t.name;
+		if (t.kind === "named") return t.name;
+		if (t.kind === "TypeName" || t.kind === "Ident") return t.name;
+	}
+	return null;
+}
+
 export function isSigned(goType) {
 	if (!goType) return true;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -329,27 +587,6 @@ export function isFloat(goType) {
 	);
 }
 
-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") {
@@ -418,3 +655,42 @@ export function getFuncSignature(goType, checker = null) {
 	}
 	return { params: [], returns: [] };
 }
+
+export function isUnhashableGoType(goType, checker = null, seen = new Set()) {
+	if (!goType) return false;
+	if (seen.has(goType)) return false;
+	seen.add(goType);
+	if (
+		isSliceType(goType, checker) ||
+		isMapType(goType, checker) ||
+		isFuncType(goType, checker)
+	) {
+		return true;
+	}
+	if (isArrayType(goType, checker)) {
+		const elem = goType.elem ?? goType.underlying?.elem;
+		return isUnhashableGoType(elem, checker, seen);
+	}
+	if (goType.kind === "struct" || goType.kind === "StructType") {
+		if (goType.fields instanceof Map) {
+			for (const f of goType.fields.values()) {
+				if (isUnhashableGoType(f, checker, seen)) return true;
+			}
+		} else if (Array.isArray(goType.fields)) {
+			for (const f of goType.fields) {
+				const fType = f.type ?? f.goType;
+				if (isUnhashableGoType(fType, checker, seen)) return true;
+			}
+		}
+	}
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved && resolved !== goType) {
+			return isUnhashableGoType(resolved, checker, seen);
+		}
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isUnhashableGoType(goType.underlying, checker, seen);
+	}
+	return false;
+}

package/src/backend/wasm/wat.js

@@ -83,6 +83,21 @@ function formatInstruction(inst) {
 		case "global.get":
 		case "global.set":
 			return `${op} ${inst.globalIndex ?? inst.index ?? 0}`;
+		case "i32.load":
+		case "i64.load":
+		case "f32.load":
+		case "f64.load":
+		case "i32.load8_s":
+		case "i32.load8_u":
+		case "i32.load16_s":
+		case "i32.load16_u":
+		case "i32.store":
+		case "i64.store":
+		case "f32.store":
+		case "f64.store":
+		case "i32.store8":
+		case "i32.store16":
+			return inst.offset ? `${op} offset=${inst.offset}` : op;
 		case "i32.const":
 		case "i64.const":
 			return `${op} ${inst.value ?? 0}`;
@@ -96,6 +111,26 @@ function formatInstruction(inst) {
 		}
 		case "throw":
 			return `${op} ${inst.tagIndex ?? inst.index ?? 0}`;
+		case "throw_ref":
+			return "throw_ref";
+		case "try_table": {
+			const bt = inst.blockType ?? inst.resultType;
+			const res = bt && bt !== "void" ? ` (result ${formatValType(bt)})` : "";
+			const catches = (inst.catches ?? [])
+				.map((c) => {
+					const k = c.kind ?? c.op;
+					if (k === "catch")
+						return `(catch ${c.tagIndex ?? 0} ${c.label ?? 0})`;
+					if (k === "catch_ref")
+						return `(catch_ref ${c.tagIndex ?? 0} ${c.label ?? 0})`;
+					if (k === "catch_all") return `(catch_all ${c.label ?? 0})`;
+					if (k === "catch_all_ref") return `(catch_all_ref ${c.label ?? 0})`;
+					return "";
+				})
+				.filter(Boolean)
+				.join(" ");
+			return `${op}${res}${catches ? ` ${catches}` : ""}`;
+		}
 		case "struct.new":
 			return `struct.new ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0}`;
 		case "struct.get":
@@ -119,8 +154,15 @@ function formatInstruction(inst) {
 		case "ref.test":
 		case "ref.test_null":
 		case "ref.cast":
-		case "ref.cast_null":
-			return `${op} ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0}`;
+		case "ref.cast_null": {
+			const ht =
+				inst.typeIndex !== undefined
+					? `$t${inst.typeIndex}`
+					: inst.heapType !== undefined
+						? String(inst.heapType)
+						: 0;
+			return `${op} ${ht}`;
+		}
 		case "any.convert_extern":
 		case "extern.convert_any":
 			return op;
@@ -166,6 +208,11 @@ export function emitWat(mod) {
 		}
 	}
 
+	if (mod.memory) {
+		const max = mod.memory.max != null ? ` ${mod.memory.max}` : "";
+		lines.push(`  (memory $mem ${mod.memory.min}${max})`);
+	}
+
 	// 4. Globals
 	if (mod.globals && mod.globals.length > 0) {
 		for (let i = 0; i < mod.globals.length; i++) {