gofront 1.6.0 → 1.7.0

package/src/backend/wasm/types.js

@@ -27,6 +27,7 @@ export function toWasmType(goType, checker = null, mod = null) {
 			goType === "i64" ||
 			goType === "f32" ||
 			goType === "f64" ||
+			goType === "v128" ||
 			goType === "anyref" ||
 			goType === "externref" ||
 			goType === "funcref"
@@ -39,6 +40,16 @@ export function toWasmType(goType, checker = null, mod = null) {
 	}
 	if (isTestingT(goType)) return "externref";
 
+	if (
+		goType.kind === "simd" ||
+		(goType.kind === "named" &&
+			(goType.name === "simd.F32x4" ||
+				goType.name === "F32x4" ||
+				goType.underlying?.kind === "simd"))
+	) {
+		return "v128";
+	}
+
 	// Pointer AST nodes
 	if (goType.kind === "PointerType") {
 		return toWasmType({ kind: "pointer", base: goType.base }, checker, mod);
@@ -68,6 +79,9 @@ export function toWasmType(goType, checker = null, mod = null) {
 
 	// TypeName AST node
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		if (goType.name === "simd.F32x4" || goType.name === "F32x4") {
+			return "v128";
+		}
 		if (mod?.getStructType(goType.name)) {
 			return {
 				kind: "ref",
@@ -84,6 +98,13 @@ export function toWasmType(goType, checker = null, mod = null) {
 
 	// Unwrap named types
 	if (goType.kind === "named") {
+		if (
+			goType.name === "simd.F32x4" ||
+			goType.name === "F32x4" ||
+			goType.underlying?.kind === "simd"
+		) {
+			return "v128";
+		}
 		if (mod?.getStructType(goType.name)) {
 			return {
 				kind: "ref",
@@ -142,6 +163,7 @@ export function toWasmType(goType, checker = null, mod = null) {
 				return "externref";
 
 			case "any":
+			case "error":
 				return "anyref";
 
 			case "void":
@@ -220,7 +242,7 @@ export function toWasmType(goType, checker = null, mod = null) {
 		return { kind: "ref", nullable: true, heapType: "struct" };
 	}
 
-	if (goType.kind === "struct") {
+	if (goType.kind === "struct" || goType.kind === "StructType") {
 		if (goType.name && mod?.getStructType(goType.name)) {
 			return {
 				kind: "ref",
@@ -228,6 +250,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" };
 	}
 
@@ -250,6 +289,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") {
@@ -378,6 +507,11 @@ export function isAnyType(goType, checker = null) {
 
 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") {
@@ -542,3 +676,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

@@ -98,6 +98,43 @@ function formatInstruction(inst) {
 		case "i32.store8":
 		case "i32.store16":
 			return inst.offset ? `${op} offset=${inst.offset}` : op;
+		case "v128.load":
+		case "v128.store": {
+			const parts = [op];
+			if (inst.offset) parts.push(`offset=${inst.offset}`);
+			if (inst.align !== undefined) parts.push(`align=${1 << inst.align}`);
+			return parts.join(" ");
+		}
+		case "v128.const": {
+			if (inst.values && inst.values.length === 4) {
+				return `${op} f32x4 ${inst.values.join(" ")}`;
+			}
+			if (inst.bytes) {
+				const b = new Uint8Array(16);
+				b.set(inst.bytes.slice(0, 16));
+				const dv = new DataView(b.buffer);
+				return `${op} i32x4 ${dv.getInt32(0, true)} ${dv.getInt32(4, true)} ${dv.getInt32(8, true)} ${dv.getInt32(12, true)}`;
+			}
+			return `${op} i32x4 0 0 0 0`;
+		}
+		case "i8x16.shuffle": {
+			const lanes = (inst.lanes ?? inst.indices ?? []).slice(0, 16);
+			while (lanes.length < 16) lanes.push(0);
+			return `${op} ${lanes.join(" ")}`;
+		}
+		case "i8x16.extract_lane_s":
+		case "i8x16.extract_lane_u":
+		case "i8x16.replace_lane":
+		case "i16x8.extract_lane_s":
+		case "i16x8.extract_lane_u":
+		case "i16x8.replace_lane":
+		case "i32x4.extract_lane":
+		case "i32x4.replace_lane":
+		case "i64x2.extract_lane":
+		case "i64x2.replace_lane":
+		case "f32x4.extract_lane":
+		case "f32x4.replace_lane":
+			return `${op} ${inst.lane ?? inst.index ?? 0}`;
 		case "i32.const":
 		case "i64.const":
 			return `${op} ${inst.value ?? 0}`;

package/src/cli-core.js

@@ -33,7 +33,7 @@ import { generatePwa } from "./pwa.js";
 import { runTests } from "./test-runner.js";
 import { bundleVendor } from "./vendor.js";
 
-const GOFRONT_VERSION = JSON.parse(
+export const GOFRONT_VERSION = JSON.parse(
 	readFileSync(new URL("../package.json", import.meta.url), "utf8"),
 ).version;
 

package/src/compiler.js

@@ -38,7 +38,7 @@ import {
 } from "./resolver.js";
 import { TemplLexer } from "./templ-lexer.js";
 import { TemplParser } from "./templ-parser.js";
-import { TypeChecker } from "./typechecker/index.js";
+import { TypeCheckError, TypeChecker } from "./typechecker/index.js";
 import { WASM_SUPPORTED_STDLIB } from "./typechecker/types.js";
 
 // ── Parse cache ──────────────────────────────────────────────
@@ -203,6 +203,7 @@ function finishWasm(options, merged, pkgTarget, outputDir) {
 			inputSourceMap: wasmSourceMap,
 			sourceMapUrl: WASM_MAP_URL,
 			emitWat: Boolean(options.emitWat),
+			converge: Boolean(options.release),
 		});
 		wasm = opt.wasm;
 		if (opt.wat) wat = opt.wat;
@@ -269,7 +270,20 @@ function linkWasmUnits(
 		for (const b of u.bundledPackages) bundledPackages.add(b);
 		programs.push(...u.programs);
 	}
-	const checker = { types };
+	const checker = {
+		types,
+		errors: [],
+		err(msg, node) {
+			const e = new TypeCheckError(
+				msg,
+				node,
+				this._currentFile,
+				this._currentSource,
+			);
+			this.errors.push(e);
+			return e;
+		},
+	};
 	const lowerRes = lower(programs, checker);
 	return compileWasmModule(programs, checker, lowerRes, {
 		boundary: true,
@@ -809,8 +823,8 @@ export function compileFiles(files, options = {}) {
 
 	const mainChunk = {
 		js: mainJs,
-		sourceFiles: files.map((f) => resolve(f)),
-		sourcesContent: files.map((f) => readFileSync(f, "utf8")),
+		sourceFiles: programs.map((p) => p._path),
+		sourcesContent: programs.map((p) => p._source),
 		mappings: emitTarget === "wasm" ? [] : codegen.getMappings(),
 	};