gofront 1.4.0 → 1.6.0

package/src/resolver.js

@@ -33,6 +33,7 @@ const BUILTIN_PACKAGES = new Set([
 	"strconv",
 	"sort",
 	"math",
+	"math/bits",
 	"math/rand",
 	"errors",
 	"time",
@@ -48,6 +49,7 @@ const BUILTIN_PACKAGES = new Set([
 	"path",
 	"path/filepath",
 	"testing",
+	"gofront/shared",
 ]);
 
 // Returns true for local relative paths (start with ./ or ../)
@@ -71,7 +73,7 @@ export function resolveGwDir(importPath, fromFile) {
 	return gwFiles.length > 0 ? dir : null;
 }
 
-export function resolveImport(importPath, fromFile) {
+function resolveImport(importPath, fromFile) {
 	const fromDir = dirname(resolve(fromFile));
 	const nodeModules = findNodeModules(fromDir);
 

package/src/test-runner.js

@@ -6,8 +6,26 @@ import { statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { HELPER_SPRINTF, HELPER_TESTING } from "./backend/js/runtime.js";
 import { colorEnabled, createColors, formatDiagnostic } from "./colors.js";
-import { compilePackageTests, gwFilesIn } from "./compiler.js";
+import {
+	compilePackageTests,
+	compilePackageTestsWasm,
+	gwFilesIn,
+} from "./compiler.js";
+
+// WasmGC + exception handling (what the wasm backend emits) ship enabled by
+// default from Node 22 (V8 11.9+). Older runtimes fail at instantiate time
+// with an opaque CompileError, so check up front and explain.
+export const MIN_WASM_NODE_MAJOR = 22;
+
+export function checkWasmRuntime(version = process.version) {
+	const major = Number.parseInt(version.replace(/^v/, ""), 10);
+	if (Number.isNaN(major) || major >= MIN_WASM_NODE_MAJOR) return;
+	throw new Error(
+		`running wasm packages requires Node ${MIN_WASM_NODE_MAJOR}+ (WasmGC); found ${version}\n  hint: upgrade Node, or compile with --js-only to run the JS backend instead`,
+	);
+}
 
 export function isTestFunc(decl) {
 	if (decl.kind !== "FuncDecl") return false;
@@ -78,7 +96,16 @@ globalThis.document = globalThis.document ?? null;
 `
 }
 globalThis.__gofront_verbose = ${verbose};
-
+${
+	options.wasmBytes
+		? `
+// ── WASM module (tests run inside app.wasm; *testing.T stays in JS) ──
+${HELPER_SPRINTF}
+${HELPER_TESTING}
+globalThis.__GOFRONT_WASM_BYTES = Uint8Array.from(atob(${JSON.stringify(Buffer.from(options.wasmBytes).toString("base64"))}), (c) => c.charCodeAt(0));
+`
+		: ""
+}
 // ── Compiled Package Bundle ──
 ${bundleJs}
 // ─────────────────────────────
@@ -281,6 +308,44 @@ function spawnTestRunner(resolvedDir, harnessJs, testCount, options) {
 	});
 }
 
+function reportBuildFailure(err, resolvedDir, options) {
+	const msg = err?.message ?? String(err);
+	if (options.captureOutput) {
+		const out = `FAIL\t${basename(resolvedDir)} [build failed]\n${msg}\n`;
+		return { exitCode: 1, stdout: "", stderr: out };
+	}
+	const dest = options.stderr ?? process.stderr;
+	const c = colorsFor(options, dest);
+	dest.write(
+		`${c.bold(c.red("FAIL"))}\t${basename(resolvedDir)} ${c.red("[build failed]")}\n${formatDiagnostic(msg, c)}\n`,
+	);
+	return { exitCode: 1 };
+}
+
+// `both` packages run twice (JS and wasm) so the two backends are kept in
+// agreement; output of both runs is concatenated.
+async function runDualTarget(compiled, resolvedDir, runHarness, options) {
+	let wasmCompiled;
+	try {
+		wasmCompiled = compilePackageTestsWasm(resolvedDir, options);
+	} catch (err) {
+		return reportBuildFailure(err, resolvedDir, options);
+	}
+	const label = compiled.pkgName;
+	const jsRun = await runHarness(compiled.js, `${label} [js]`, null);
+	const wasmRun = await runHarness(
+		wasmCompiled.js,
+		`${label} [wasm]`,
+		wasmCompiled.wasm,
+	);
+	return {
+		exitCode: jsRun.exitCode !== 0 ? jsRun.exitCode : wasmRun.exitCode,
+		stdout: jsRun.stdout + wasmRun.stdout,
+		stderr: jsRun.stderr + wasmRun.stderr,
+		testCount: jsRun.testCount + wasmRun.testCount,
+	};
+}
+
 export async function runTests(targetDir, options = {}) {
 	let resolvedDir = resolve(targetDir);
 	try {
@@ -304,17 +369,7 @@ export async function runTests(targetDir, options = {}) {
 	try {
 		compiled = compilePackageTests(resolvedDir, options);
 	} catch (err) {
-		const msg = err?.message ?? String(err);
-		if (options.captureOutput) {
-			const out = `FAIL\t${basename(resolvedDir)} [build failed]\n${msg}\n`;
-			return { exitCode: 1, stdout: "", stderr: out };
-		}
-		const dest = options.stderr ?? process.stderr;
-		const c = colorsFor(options, dest);
-		dest.write(
-			`${c.bold(c.red("FAIL"))}\t${basename(resolvedDir)} ${c.red("[build failed]")}\n${formatDiagnostic(msg, c)}\n`,
-		);
-		return { exitCode: 1 };
+		return reportBuildFailure(err, resolvedDir, options);
 	}
 
 	const { pkgName, js, programs } = compiled;
@@ -324,12 +379,31 @@ export async function runTests(targetDir, options = {}) {
 		return reportEmptyTests(pkgName, "no tests to run", options);
 	}
 
-	const harnessJs = generateTestHarness(js, testNames, {
-		...options,
-		pkgName,
-		jsdomPath,
-		color: colorsFor(options, options.stdout ?? process.stdout).enabled,
-	});
+	const runHarness = (bundleJs, label, wasmBytes) =>
+		spawnTestRunner(
+			resolvedDir,
+			generateTestHarness(bundleJs, testNames, {
+				...options,
+				pkgName: label,
+				jsdomPath,
+				wasmBytes,
+				color: colorsFor(options, options.stdout ?? process.stdout).enabled,
+			}),
+			testNames.length,
+			options,
+		);
 
-	return spawnTestRunner(resolvedDir, harnessJs, testNames.length, options);
+	// `wasm` packages run inside the linked app.wasm; `js` packages that import
+	// wasm packages need the linked module too (hybrid packages).
+	if (compiled.target === "both" || compiled.wasm) {
+		try {
+			checkWasmRuntime();
+		} catch (err) {
+			return reportBuildFailure(err, resolvedDir, options);
+		}
+	}
+	if (compiled.target === "both") {
+		return runDualTarget(compiled, resolvedDir, runHarness, options);
+	}
+	return runHarness(js, pkgName, compiled.wasm ?? null);
 }

package/src/typechecker/assignability.js

@@ -1,6 +1,7 @@
 // Assignability, binary result types, and interface satisfaction.
 // Installed as a mixin on TypeChecker.prototype.
 
+import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
 	BOOL,
@@ -159,6 +160,7 @@ export const assignabilityMethods = {
 		target = this.resolveType(target);
 		source = this.resolveType(source);
 		this._markIfaceBox(target, source, node);
+		this._checkWasmIfaceProvider(target, source, node);
 		if (this._assertAssignableEarlyReturn(target, source)) return;
 		if (isPointer(target) && isPointer(source)) {
 			this.assertAssignable(
@@ -200,6 +202,24 @@ export const assignabilityMethods = {
 			node._ifaceBox = "ptr";
 	},
 
+	// A js package cannot provide an implementation of a wasm interface: the
+	// value would cross into wasm, and JS-implemented proxies are not supported.
+	_checkWasmIfaceProvider(target, source, node) {
+		if (this.target !== "js" || target?.kind !== "named") return;
+		if (target._target !== "wasm" || !source) return;
+		const iface = this.resolveType(target.underlying);
+		if (iface?.kind !== "interface" || !(iface.methods?.size > 0)) return;
+		const ptr = source.kind === "pointer";
+		const src = ptr ? this.resolveType(source.base) : source;
+		if (src?.kind !== "named" || src._target === "wasm") return;
+		if (this.resolveType(src.underlying)?.kind === "interface") return;
+		if (!this.implements(source, iface, node)) return;
+		this.err(
+			`type '${ptr ? "*" : ""}${src.name}' (${src._target ?? "js"}) cannot implement wasm interface '${target.name}' across the boundary; implement it in a wasm package or pass a func callback`,
+			node,
+		);
+	},
+
 	_assertAssignableEarlyReturn(target, source) {
 		return (
 			target?.kind === "typeParam" ||
@@ -222,6 +242,23 @@ export const assignabilityMethods = {
 				);
 			return;
 		}
+		const sBase = this.resolveType(
+			source.kind === "named" ? source.underlying : source,
+		);
+		if (sharedInfo(source) && tBase?.kind === "slice") {
+			this.err(
+				`cannot use ${typeStr(source)} as ${typeStr(target)}: a linear-memory buffer cannot be passed as a GC slice without an explicit copy`,
+				node,
+			);
+			return;
+		}
+		if (tBase?.kind === "shared" && sBase?.kind === "slice") {
+			this.err(
+				`cannot use ${typeStr(source)} as ${typeStr(target)}: a GC slice cannot be used as a shared buffer; copy its elements into one allocated with shared.New${tBase.shared}`,
+				node,
+			);
+			return;
+		}
 		this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
 	},
 
@@ -346,6 +383,7 @@ export const assignabilityMethods = {
 	},
 
 	implements(srcType, iface, _node) {
+		const isPtr = srcType?.kind === "pointer";
 		// *T has the full method set of T (value + pointer receivers).
 		if (srcType?.kind === "pointer") srcType = this.resolveType(srcType.base);
 		let base = srcType.kind === "named" ? srcType.underlying : srcType;
@@ -366,7 +404,10 @@ export const assignabilityMethods = {
 					: null;
 		if (!methodMap) return false;
 		for (const [name, required] of iface.methods) {
-			if (!this._implementsMethod(required, methodMap.get(name))) return false;
+			const actual = methodMap.get(name);
+			if (!actual) return false;
+			if (!isPtr && actual._ptrRecv) return false;
+			if (!this._implementsMethod(required, actual)) return false;
 		}
 		return true;
 	},

package/src/typechecker/expressions.js

@@ -1,8 +1,10 @@
 // TypeChecker expression-checking methods — installed as a mixin on TypeChecker.prototype.
 
+import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
 	BOOL,
+	BROWSER_GLOBALS,
 	COMPLEX128,
 	ERROR,
 	FLOAT64,
@@ -41,6 +43,13 @@ const BUILTIN_CHECK = {
 			s.err(`cannot append to array (type ${typeStr(st)})`, e);
 			return st;
 		}
+		if (sharedInfo(st)) {
+			s.err(
+				`cannot append to ${typeStr(st)}: shared buffers have a fixed size`,
+				e,
+			);
+			return st;
+		}
 		const sb = s.resolveType(st?.kind === "named" ? st.underlying : st);
 		if (sb?.kind === "slice") {
 			for (let i = 1; i < e.args.length; i++) {
@@ -54,7 +63,7 @@ const BUILTIN_CHECK = {
 		}
 		return st;
 	},
-	copy: () => INT,
+	copy: (s, _n, e, at) => s._checkBuiltinCopy(e, at),
 	delete: () => VOID,
 	make: (s, _n, e, _at, sc) => {
 		if (e.args.length < 1) return ANY;
@@ -126,6 +135,26 @@ export const expressionCheckMethods = {
 				const t = scope.lookup(expr.name);
 				if (!t) return this.err(`Undefined: '${expr.name}'`, expr);
 				if (this.types.has(expr.name)) expr._isTypeRef = true;
+				if (
+					(this.target === "wasm" || this.target === "both") &&
+					BROWSER_GLOBALS.has(expr.name) &&
+					scope.lookup(expr.name) === this.globals.lookup(expr.name)
+				) {
+					this.recordBlocker("browser global", expr.name);
+					this.err(
+						`'${expr.name}' is not available in wasm packages`,
+						expr,
+						`(package '${this.pkgName}' is //gofront:target ${this.target} — browser globals are only available in js packages)`,
+					);
+				}
+				if (
+					(this.target === "wasm" || this.target === "both") &&
+					expr.name === "gom" &&
+					scope.lookup(expr.name) === this.globals.lookup(expr.name)
+				) {
+					this.recordBlocker("gom usage", "gom");
+					this.err("package 'gom' is not available in wasm packages", expr);
+				}
 				return t;
 			}
 			case "BinaryExpr": {
@@ -136,8 +165,16 @@ export const expressionCheckMethods = {
 					return this.binaryResultType(expr.op, ANY, ANY, expr);
 				return this.binaryResultType(expr.op, lt, rt, expr);
 			}
-			case "AwaitExpr":
+			case "AwaitExpr": {
+				if (this.target === "wasm" || this.target === "both") {
+					this.recordBlocker("async function");
+					this.err(
+						"async functions are not supported in wasm packages; keep async code in a js package",
+						expr,
+					);
+				}
 				return this.checkExpr(expr.expr, scope);
+			}
 			case "InstantiationExpr":
 				return this._checkInstantiationExpr(expr, scope);
 			default: {
@@ -262,10 +299,42 @@ export const expressionCheckMethods = {
 			expr._mapValueType = btu.value;
 			return btu.value;
 		}
+		if (btu.kind === "shared") {
+			expr._sharedElem = btu.elem;
+			const idx = this._constIntValue(expr.index);
+			if (idx !== null && idx < 0)
+				this.err(`invalid index ${idx} (index must not be negative)`, expr);
+			return btu.elem;
+		}
 		if (isString(bt)) return INT;
 		return this.err(`Cannot index type ${typeStr(bt)}`, expr);
 	},
 
+	// copy(dst, src): element types must be identical when either side is a
+	// shared buffer (the wasm emitter uses one element type for both sides).
+	_checkBuiltinCopy(e, at) {
+		const elemOf = (t) => {
+			const u = this.resolveType(t?.kind === "named" ? t.underlying : t);
+			return u?.kind === "slice" || u?.kind === "shared" ? u.elem : null;
+		};
+		const [dt, st] = at;
+		if (!sharedInfo(dt) && !sharedInfo(st)) return INT;
+		const de = elemOf(dt);
+		const se = elemOf(st);
+		if (!de || !se) {
+			this.err(
+				`copy: cannot copy between ${typeStr(dt)} and ${typeStr(st)}`,
+				e,
+			);
+		} else if (typeStr(de) !== typeStr(se)) {
+			this.err(
+				`copy: element types differ (${typeStr(dt)} vs ${typeStr(st)})`,
+				e,
+			);
+		}
+		return INT;
+	},
+
 	_checkSliceExpr(expr, scope) {
 		const bt = this.checkExpr(expr.expr, scope);
 		if (expr.low) this.checkExpr(expr.low, scope);
@@ -276,10 +345,35 @@ export const expressionCheckMethods = {
 		if (bt.kind === "slice" || bt.kind === "array")
 			return { kind: "slice", elem: bt.elem };
 		if (isString(bt)) return STRING;
+		if (sharedInfo(bt))
+			return this.err(
+				`Cannot slice type ${typeStr(bt)}: use .Subarray(lo, hi) to create a view of a shared buffer`,
+				expr,
+			);
 		return this.err(`Cannot slice type ${typeStr(bt)}`, expr);
 	},
 
 	_checkFuncLit(expr, scope) {
+		const savedSharedAlloc = this._sharedAllocOk;
+		this._sharedAllocOk = false;
+		try {
+			return this._checkFuncLitBody(expr, scope);
+		} finally {
+			this._sharedAllocOk = savedSharedAlloc;
+		}
+	},
+
+	_checkFuncLitBody(expr, scope) {
+		if (
+			(this.target === "wasm" || this.target === "both") &&
+			(expr.async || expr.isAsync)
+		) {
+			this.recordBlocker("async function");
+			this.err(
+				"async functions are not supported in wasm packages; keep async code in a js package",
+				expr,
+			);
+		}
 		const inner = new Scope(scope);
 		for (const p of expr.params)
 			inner.define(p.name, p.type ? this.resolveTypeNode(p.type, scope) : ANY);
@@ -392,7 +486,11 @@ export const expressionCheckMethods = {
 
 	_rangeCollTypeTuple(resolved, collType) {
 		if (isString(resolved)) return { kind: "tuple", types: [INT, RUNE] };
-		if (resolved?.kind === "slice" || resolved?.kind === "array")
+		if (
+			resolved?.kind === "slice" ||
+			resolved?.kind === "array" ||
+			resolved?.kind === "shared"
+		)
 			return { kind: "tuple", types: [INT, resolved.elem ?? ANY] };
 		if (resolved?.kind === "map")
 			return {
@@ -428,6 +526,9 @@ export const expressionCheckMethods = {
 					: null;
 				if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
 			}
+			expr._typeArgs = typeArgs;
+			if (expr.expr) expr.expr._typeArgs = typeArgs;
+			expr._genericFnType = baseType;
 			return this.instantiateGenericFunc(baseType, typeArgs);
 		}
 		// The parser's type-arg heuristic mistakes `xs[d.Field]` (uppercase field
@@ -507,6 +608,8 @@ export const expressionCheckMethods = {
 
 	checkCall(expr, scope) {
 		let fnType = this.checkExpr(expr.func, scope);
+		this._checkSharedAllocSite(expr, scope);
+		this._checkBoundaryCallInLoop(expr, scope);
 		if (fnType.kind === "builtin") {
 			const argTypes = expr.args.map((a, i) => {
 				// new(T) — first arg is a type name, not a value expression
@@ -537,12 +640,79 @@ export const expressionCheckMethods = {
 
 		this._checkCallArgs(fnType, argTypes, expr);
 
+		// Pseudo-generic stdlib helpers (maps.Keys, slices.Clone, ...) declare
+		// how their result derives from the first argument.
+		if (fnType._derivedReturn) {
+			const derived = this._derivedReturnType(fnType._derivedReturn, argTypes);
+			if (derived) return derived;
+		}
+
 		const ret = fnType.returns;
 		if (!ret || ret.length === 0) return VOID;
 		if (ret.length === 1) return ret[0];
 		return { kind: "tuple", types: ret };
 	},
 
+	// `shared.NewXxx(n)` allocates from a linear memory that is sized once at
+	// startup (no memory.grow → no detached TypedArray views on the JS side).
+	// Allocation is therefore only legal in package-level var initializers and
+	// init(), which both run inside the module start function.
+	// JS→WASM calls copy non-shared arguments across the boundary on every
+	// call. Inside a loop that dominates the per-iteration cost, so hint that
+	// the loop belongs on the WASM side (or the data in gofront/shared).
+	_checkBoundaryCallInLoop(expr, scope) {
+		if (this._loopDepth === 0 || this.target !== "js") return;
+		const fn = expr.func;
+		if (fn.kind !== "SelectorExpr" || fn.expr.kind !== "Ident") return;
+		const ns = scope.lookup(fn.expr.name);
+		if (ns?.kind !== "namespace" || ns._target !== "wasm") return;
+		const member = ns.members[fn.field];
+		if (member?.kind !== "func") return;
+		this.warn(
+			`'${fn.expr.name}.${fn.field}' crosses the JS→WASM boundary inside a loop`,
+			fn.expr, // CallExpr nodes carry no position; the callee Ident does
+			"hint: each call copies its arguments; move the loop into the wasm package or pass gofront/shared buffers",
+		);
+	},
+
+	_checkSharedAllocSite(expr, scope) {
+		const f = expr.func;
+		if (
+			f.kind !== "SelectorExpr" ||
+			f.expr.kind !== "Ident" ||
+			f.expr.name !== "shared" ||
+			!f.field.startsWith("New") ||
+			scope.lookup("shared") !== this.globals.lookup("shared")
+		)
+			return;
+		if (this._sharedAllocOk) return;
+		const why =
+			this.target === "wasm"
+				? "shared buffers are allocated once at startup"
+				: "shared buffers are allocated once at startup so the code stays portable to wasm packages";
+		this.err(
+			`shared.${f.field} must be called from a package-level var initializer or init(); ${why}`,
+			expr,
+		);
+	},
+
+	_derivedReturnType(mode, argTypes) {
+		const arg = argTypes[0];
+		const under = arg?.kind === "named" ? arg.underlying : arg;
+		switch (mode) {
+			case "arg0":
+				return under ? arg : null;
+			case "keysOfArg0":
+				return under?.key ? { kind: "slice", elem: under.key } : null;
+			case "valuesOfArg0": {
+				const v = under?.value ?? under?.elem;
+				return v ? { kind: "slice", elem: v } : null;
+			}
+			default:
+				return null;
+		}
+	},
+
 	_resolveGenericFnType(fnType, argTypes, expr, scope) {
 		const typeArgs = this.inferTypeArgs(fnType, argTypes);
 		if (!typeArgs) {
@@ -560,6 +730,10 @@ export const expressionCheckMethods = {
 				: null;
 			if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
 		}
+		expr._typeArgs = typeArgs;
+		if (expr.func) expr.func._typeArgs = typeArgs;
+		expr._genericFnType = fnType;
+		if (expr.func) expr.func._genericFnType = fnType;
 		return this.instantiateGenericFunc(fnType, typeArgs);
 	},
 
@@ -611,6 +785,11 @@ export const expressionCheckMethods = {
 		if (name === "len") {
 			const size = this._constLenFromType(argTypes[0]);
 			if (size != null) expr._constLen = size;
+		} else if (sharedInfo(argTypes[0])) {
+			this.err(
+				`cannot use cap() on ${typeStr(argTypes[0])}: shared buffers have a fixed size; use len()`,
+				expr,
+			);
 		}
 		return INT;
 	},