gofront 1.4.0 → 1.5.1

package/src/parser/index.js

@@ -114,6 +114,8 @@ export class Parser {
 			pkg,
 			imports,
 			decls,
+			target: this.tokens?.target ?? null,
+			_targetDirective: this.tokens?.targetDirective ?? null,
 			_filename: this.filename,
 			_source: this.source,
 		};
@@ -130,7 +132,9 @@ export class Parser {
 		this.expect(T.IMPORT);
 		const imports = [];
 		const parseOne = () => {
-			const _line = this.peek().line;
+			const tok = this.peek();
+			const _line = tok.line;
+			const _col = tok.col;
 			let alias = null;
 			if (this.check(T.IDENT)) {
 				alias = this.advance().value;
@@ -138,8 +142,9 @@ export class Parser {
 				alias = ".";
 				this.advance();
 			}
-			const path = this.expect(T.STRING).value;
-			return { path, alias, _line };
+			const pathTok = this.expect(T.STRING);
+			const path = pathTok.value;
+			return { path, alias, _line, _col, line: pathTok.line, col: pathTok.col };
 		};
 		if (this.match(T.LPAREN)) {
 			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {

package/src/resolver.js

@@ -33,6 +33,7 @@ const BUILTIN_PACKAGES = new Set([
 	"strconv",
 	"sort",
 	"math",
+	"math/bits",
 	"math/rand",
 	"errors",
 	"time",

package/src/test-runner.js

@@ -6,8 +6,13 @@ 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";
 
 export function isTestFunc(decl) {
 	if (decl.kind !== "FuncDecl") return false;
@@ -78,7 +83,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 +295,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 +356,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 +366,24 @@ 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") {
+		return runDualTarget(compiled, resolvedDir, runHarness, options);
+	}
+	return runHarness(js, pkgName, compiled.wasm ?? null);
 }

package/src/typechecker/expressions.js

@@ -3,6 +3,7 @@
 import {
 	ANY,
 	BOOL,
+	BROWSER_GLOBALS,
 	COMPLEX128,
 	ERROR,
 	FLOAT64,
@@ -126,6 +127,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 +157,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: {
@@ -280,6 +309,16 @@ export const expressionCheckMethods = {
 	},
 
 	_checkFuncLit(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);

package/src/typechecker/index.js

@@ -25,9 +25,18 @@ import {
 	TAINTED_ANY,
 	TypeCheckError,
 	typeStr,
+	VALID_TARGETS,
 	VOID,
 } from "./types.js";
 
+function rootIdentName(e) {
+	if (!e) return null;
+	if (e.kind === "Ident") return e.name;
+	if (e.kind === "SelectorExpr" || e.kind === "IndexExpr")
+		return rootIdentName(e.expr);
+	return null;
+}
+
 // Re-export for consumers that import from typechecker.js
 export { TypeCheckError, typeStr };
 
@@ -36,6 +45,10 @@ export class TypeChecker {
 		this.types = new Map(); // named types
 		this.globals = new Scope();
 		this.errors = [];
+		this.target = "js";
+		this.pkgName = null;
+		this.blockers = new Map();
+		this.summary = null;
 		this._currentFile = null; // filename of file currently being checked
 		this._currentSource = null;
 		this._loopDepth = 0; // for break/continue validation
@@ -117,12 +130,42 @@ export class TypeChecker {
 		return new Map(this.types);
 	}
 
-	err(msg, node) {
+	recordBlocker(category, item = null) {
+		if (!this.blockers.has(category)) {
+			this.blockers.set(category, []);
+		}
+		this.blockers.get(category).push(item);
+	}
+
+	getSummary() {
+		if (this.blockers.size === 0) return null;
+		let total = 0;
+		const parts = [];
+		for (const [category, items] of this.blockers) {
+			const uniqueItems = [
+				...new Set(items.filter((x) => x != null && x !== "")),
+			];
+			const count = uniqueItems.length > 0 ? uniqueItems.length : items.length;
+			total += count;
+			const itemsStr =
+				uniqueItems.length > 0 ? ` (${uniqueItems.join(", ")})` : "";
+			// "gom usage" is a mass noun; everything else pluralises on the last word.
+			const label =
+				count === 1 || category === "gom usage" ? category : `${category}s`;
+			parts.push(`${count} ${label}${itemsStr}`);
+		}
+		const noun = total === 1 ? "blocker" : "blockers";
+		const what = this.target === "both" ? "both" : "wasm";
+		return `package '${this.pkgName}' cannot be ${what}: ${total} ${noun} — ${parts.join(", ")}`;
+	}
+
+	err(msg, node, hint = null) {
 		const e = new TypeCheckError(
 			msg,
 			node,
 			this._currentFile,
 			this._currentSource,
+			hint,
 		);
 		this.errors.push(e);
 		return TAINTED_ANY; // tainted recovery type — suppresses downstream cascade errors
@@ -163,18 +206,181 @@ export class TypeChecker {
 		}
 	}
 
-	// Like check() but operates over multiple programs (same-package multi-file).
-	// All passes run across all files before moving to the next pass,
-	// so every file sees every other file's declarations.
 	checkAll(programs) {
+		for (const p of programs) {
+			const d = p._targetDirective;
+			if (!d) continue;
+			this._setCurrentFile(p);
+			if (!VALID_TARGETS.has(d.value)) {
+				this.err(
+					`unknown //gofront:target '${d.value}' (expected js, wasm or both)`,
+					d,
+				);
+				p.target = null;
+				if (this.target === d.value) this.target = "js";
+			} else if (!d.beforePackage) {
+				this.err("//gofront:target must appear before the package clause", d);
+			}
+		}
+		if (programs.length > 0) {
+			if (!this.target || this.target === "js") {
+				const pTarget = programs.find((p) => p.target)?.target;
+				if (pTarget) this.target = pTarget;
+			}
+			if (!this.pkgName) {
+				this.pkgName = programs[0].pkg?.name ?? null;
+			}
+		}
+
+		if (this.target === "wasm" || this.target === "both") {
+			for (const p of programs) {
+				if (p._filename?.endsWith(".templ")) {
+					this._setCurrentFile(p);
+					const fileName = p._filename.split("/").pop();
+					this.recordBlocker(".templ file", fileName);
+					this.err(
+						`.templ files are not allowed in wasm packages; move '${fileName}' to a js package`,
+						p.pkg,
+					);
+				}
+			}
+		}
+
 		this._collectTypesPass(programs);
 		this._collectFuncsPass(programs);
 		this._promoteEmbeddedMethods();
 		this._collectVarsConstsPass(programs);
 		this._checkTopDeclsPass(programs);
+
+		if (this.target === "both") {
+			this._checkMutablePackageVars(programs);
+		}
+
+		if (this.blockers.size > 0) {
+			const summaryLine = this.getSummary();
+			this.summary = summaryLine;
+			const summaryErr = new Error(summaryLine);
+			summaryErr.isSummary = true;
+			this.errors.push(summaryErr);
+		}
+
 		return this.errors;
 	}
 
+	_checkMutablePackageVars(programs) {
+		const pkgVars = new Set();
+		for (const p of programs) {
+			for (const d of p.decls) {
+				if (d.kind === "VarDecl") {
+					for (const spec of d.decls) {
+						for (const name of spec.names) {
+							if (name !== "_") pkgVars.add(name);
+						}
+					}
+				}
+			}
+		}
+		if (pkgVars.size === 0) return;
+
+		const SCOPE_KINDS = new Set([
+			"Block",
+			"FuncLit",
+			"ForStmt",
+			"IfStmt",
+			"SwitchStmt",
+			"TypeSwitchStmt",
+			"CaseClause",
+		]);
+
+		const report = (root, node) => {
+			this.recordBlocker("mutable package variable", root);
+			this.err(
+				`package-level variable '${root}' is mutated; not allowed in 'both' packages (each target gets its own copy)`,
+				node,
+			);
+		};
+
+		const checkBody = (body, initialLocals) => {
+			const scopes = [new Set(initialLocals)];
+			const isLocal = (name) => scopes.some((s) => s.has(name));
+			const declare = (name) => {
+				if (name && name !== "_") scopes[scopes.length - 1].add(name);
+			};
+			const flag = (e, node) => {
+				const root = rootIdentName(e);
+				if (root && pkgVars.has(root) && !isLocal(root)) report(root, node);
+			};
+
+			const walk = (node) => {
+				if (!node || typeof node !== "object") return;
+				if (Array.isArray(node)) {
+					for (const item of node) walk(item);
+					return;
+				}
+				const opensScope = SCOPE_KINDS.has(node.kind);
+				if (opensScope) scopes.push(new Set());
+				switch (node.kind) {
+					case "FuncLit":
+						for (const p of node.params ?? []) declare(p.name);
+						for (const r of node.returnType?._namedReturns ?? [])
+							declare(r.name);
+						break;
+					case "VarDecl":
+						for (const spec of node.decls ?? [])
+							for (const name of spec.names ?? []) declare(name);
+						break;
+					case "DefineStmt":
+						for (const e of node.lhs ?? [])
+							if (e.kind === "Ident") declare(e.name);
+						break;
+					case "TypeSwitchStmt":
+						declare(node.assign);
+						break;
+					case "AssignStmt":
+						for (const e of node.lhs) flag(e, node);
+						break;
+					case "IncDecStmt":
+						flag(node.expr, node);
+						break;
+					case "UnaryExpr":
+						if (node.op === "&") flag(node.operand, node);
+						break;
+					case "SelectorExpr":
+						// Pointer-receiver method call or value: `G.Bump()` mutates G.
+						if (node._isMethodValue && node._type?._ptrRecv)
+							flag(node.expr, node);
+						break;
+				}
+				for (const key of Object.keys(node)) {
+					if (key.startsWith("_")) continue;
+					walk(node[key]);
+				}
+				if (opensScope) scopes.pop();
+			};
+			walk(body);
+		};
+
+		for (const p of programs) {
+			if (p._filename?.endsWith("_test.go")) continue;
+			this._currentFile = p._filename;
+			this._currentSource = p._source;
+			for (const d of p.decls) {
+				if ((d.kind === "FuncDecl" || d.kind === "MethodDecl") && d.body) {
+					if (d.name === "init" && d.kind === "FuncDecl") continue;
+					const locals = [];
+					if (d.recvName) locals.push(d.recvName);
+					for (const prm of d.params ?? []) if (prm.name) locals.push(prm.name);
+					for (const r of d.returnType?._namedReturns ?? [])
+						if (r.name) locals.push(r.name);
+					checkBody(d.body, locals);
+				} else if (d.kind === "VarDecl") {
+					// Closures in package-level initializers run after init.
+					for (const spec of d.decls ?? []) checkBody(spec.value, []);
+				}
+			}
+		}
+	}
+
 	_collectTypesPass(programs) {
 		for (const p of programs) {
 			for (const d of p.decls) {
@@ -507,6 +713,10 @@ export class TypeChecker {
 	}
 
 	_collectCssDecl(decl) {
+		if (this.target === "wasm" || this.target === "both") {
+			this.recordBlocker("css declaration");
+			this.err("css declarations are not allowed in wasm packages", decl);
+		}
 		const paramTypes = (decl.params || []).map((p) =>
 			this.resolveTypeNode(p.type, this.globals),
 		);
@@ -551,6 +761,16 @@ export class TypeChecker {
 	}
 
 	checkFuncDecl(decl, outer) {
+		if (
+			(this.target === "wasm" || this.target === "both") &&
+			(decl.async || decl.isAsync)
+		) {
+			this.recordBlocker("async function", decl.name);
+			this.err(
+				"async functions are not supported in wasm packages; keep async code in a js package",
+				decl,
+			);
+		}
 		const inner = new Scope(outer);
 		this._injectTypeParams(decl, inner, outer);
 		for (const p of decl.params) {
@@ -562,6 +782,16 @@ export class TypeChecker {
 	}
 
 	checkMethodDecl(decl, outer) {
+		if (
+			(this.target === "wasm" || this.target === "both") &&
+			(decl.async || decl.isAsync)
+		) {
+			this.recordBlocker("async function", decl.name);
+			this.err(
+				"async functions are not supported in wasm packages; keep async code in a js package",
+				decl,
+			);
+		}
 		const inner = new Scope(outer);
 		const recvTypeName =
 			decl.recvType.kind === "GenericTypeName"

package/src/typechecker/statements.js

@@ -43,6 +43,13 @@ export const statementCheckMethods = {
 				this.checkExpr(stmt.expr, scope);
 				break;
 			case "DeferStmt":
+				if (this.target === "wasm" || this.target === "both") {
+					this.recordBlocker("defer statement");
+					this.err(
+						"'defer' is not yet supported in wasm packages (planned)",
+						stmt,
+					);
+				}
 				if (stmt.call.kind !== "CallExpr")
 					this.err("defer requires a function call", stmt.call);
 				this.checkExpr(stmt.call, scope);

package/src/typechecker/stdlib/core.js

@@ -9,6 +9,8 @@ import {
 	INT,
 	STRING,
 	UINT8,
+	UINT32,
+	UINT64,
 	VOID,
 } from "../types.js";
 
@@ -428,6 +430,21 @@ export function setupCoreGlobals(globals, types) {
 		},
 	});
 
+	globals.define("bits", {
+		kind: "namespace",
+		name: "bits",
+		members: {
+			LeadingZeros32: { kind: "func", params: [UINT32], returns: [INT] },
+			TrailingZeros32: { kind: "func", params: [UINT32], returns: [INT] },
+			OnesCount32: { kind: "func", params: [UINT32], returns: [INT] },
+			RotateLeft32: { kind: "func", params: [UINT32, INT], returns: [UINT32] },
+			LeadingZeros64: { kind: "func", params: [UINT64], returns: [INT] },
+			TrailingZeros64: { kind: "func", params: [UINT64], returns: [INT] },
+			OnesCount64: { kind: "func", params: [UINT64], returns: [INT] },
+			RotateLeft64: { kind: "func", params: [UINT64, INT], returns: [UINT64] },
+		},
+	});
+
 	globals.define("errors", {
 		kind: "namespace",
 		name: "errors",

package/src/typechecker/types.js

@@ -13,7 +13,7 @@
 //   { kind: 'named',     name: string, underlying: Type }
 
 export class TypeCheckError extends Error {
-	constructor(msg, node, filename, sourceCode) {
+	constructor(msg, node, filename, sourceCode, hint = null) {
 		const lineNum = node?.line || node?._line;
 		const colNum = node?.col || node?._col;
 		const loc = filename
@@ -23,6 +23,7 @@ export class TypeCheckError extends Error {
 			: lineNum
 				? ` at line ${lineNum}:${colNum ?? 1}`
 				: "";
+		const hintText = hint ? `\n  ${hint}` : "";
 		let lineContext = "";
 		if (lineNum && sourceCode) {
 			const lines = sourceCode.split("\n");
@@ -33,10 +34,63 @@ export class TypeCheckError extends Error {
 				lineContext = `\n${prefix}${lineStr}\n${" ".repeat(prefix.length)}${caretPad}^`;
 			}
 		}
-		super(`Type error${loc}: ${msg}${lineContext}`);
+		super(`Type error${loc}: ${msg}${hintText}${lineContext}`);
+		this.line = lineNum;
+		this.col = colNum;
 	}
 }
 
+export const BROWSER_GLOBALS = new Set([
+	"console",
+	"document",
+	"window",
+	"navigator",
+	"location",
+	"history",
+	"screen",
+	"performance",
+	"crypto",
+	"indexedDB",
+	"fetch",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"Math",
+	"JSON",
+	"Date",
+	"RegExp",
+	"Promise",
+	"Error",
+	"Symbol",
+	"String",
+	"Number",
+	"Boolean",
+	"Array",
+	"Object",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"encodeURIComponent",
+	"decodeURIComponent",
+	"atob",
+	"btoa",
+	"alert",
+	"confirm",
+	"prompt",
+	"localStorage",
+	"sessionStorage",
+]);
+
+// Stdlib packages the WASM backend can emit. Extend as src/backend/wasm/emit.js gains support;
+// anything not listed is rejected at import with "not yet available in wasm packages".
+export const WASM_SUPPORTED_STDLIB = new Set(["math", "math/bits", "testing"]);
+
+export const VALID_TARGETS = new Set(["js", "wasm", "both"]);
+
 // ── Static operator sets (module-level for reuse) ────────────
 export const CMP_OPS = new Set(["==", "!=", "<", ">", "<=", ">="]);
 export const LOG_OPS = new Set(["&&", "||"]);