gofront 1.5.1 → 1.6.1

package/src/compiler.js

@@ -18,9 +18,13 @@
 // de-qualifies it because the dependency is inlined.
 
 import { readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
-import { buildSourceMap, CodeGen } from "./backend/js/index.js";
-import { compileWasmModule } from "./backend/wasm/index.js";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import {
+	buildSourceMap,
+	buildWasmSourceMap,
+	CodeGen,
+} from "./backend/js/index.js";
+import { compileWasmModule, optimizeWasm } from "./backend/wasm/index.js";
 import { log } from "./colors.js";
 import { parseDts } from "./dts-parser.js";
 import { Lexer } from "./lexer.js";
@@ -34,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 ──────────────────────────────────────────────
@@ -67,6 +71,9 @@ function parseGoFrontFile(filePath) {
 		? new TemplParser(tokens, filename, source).parse()
 		: new Parser(tokens, filename, source).parse();
 	ast._source = source;
+	ast._path = resolve(filePath);
+	// compileFiles overwrites `target` with the resolved one; keep the directive.
+	ast._declaredTarget = ast.target;
 	_parseCache.set(filePath, { mtime, ast });
 	return ast;
 }
@@ -163,6 +170,49 @@ function attachSourceMap(merged, outputDir) {
 	merged.js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 }
 
+const WASM_MAP_URL = "app.wasm.map";
+
+// Function-level `app.wasm.map` (sources relative to the output dir).
+function buildWasmMap(info, outputDir) {
+	if (!info || info.mappings.length === 0) return null;
+	return buildWasmSourceMap(
+		info.sources.map((f) => relative(outputDir, f)),
+		info.mappings,
+	);
+}
+
+// Shared tail of compileFiles / compileSingleFile: link `app.wasm`, run
+// wasm-opt when requested and produce the wasm source map.
+function finishWasm(options, merged, pkgTarget, outputDir) {
+	const wantMap = Boolean(options.sourceMap && !options.isDependency);
+	let { wasm, wat, sourceMapInfo } = linkIntoBundle(
+		options,
+		merged,
+		pkgTarget,
+		{
+			sourceMappingURL: wantMap ? WASM_MAP_URL : null,
+		},
+	);
+	let wasmOptInfo = null;
+	let wasmSourceMap =
+		wantMap && wasm ? buildWasmMap(sourceMapInfo, outputDir) : null;
+
+	if (wasm && options.wasmOpt) {
+		const opt = optimizeWasm(wasm, {
+			sourceMap: Boolean(wasmSourceMap),
+			inputSourceMap: wasmSourceMap,
+			sourceMapUrl: WASM_MAP_URL,
+			emitWat: Boolean(options.emitWat),
+			converge: Boolean(options.release),
+		});
+		wasm = opt.wasm;
+		if (opt.wat) wat = opt.wat;
+		wasmOptInfo = opt;
+		if (opt.sourceMap) wasmSourceMap = opt.sourceMap;
+	}
+	return { wasm, wat, wasmOptInfo, wasmSourceMap };
+}
+
 // ── WASM linking ──────────────────────────────────────────────
 //
 // Every `wasm`/`both` package reached during a build registers a unit in the
@@ -205,7 +255,10 @@ function registerPackageUnit(options, unit) {
 	return emitTarget;
 }
 
-function linkWasmUnits(units, { emitWat = false, rootTarget = "js" } = {}) {
+function linkWasmUnits(
+	units,
+	{ emitWat = false, rootTarget = "js", sourceMappingURL = null } = {},
+) {
 	if (!units.some((u) => u.target === "wasm")) return null;
 	checkLinkCollisions(units);
 
@@ -217,13 +270,27 @@ function linkWasmUnits(units, { emitWat = false, rootTarget = "js" } = {}) {
 		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,
 		bundledPackages,
 		emitWat,
 		callMain: rootTarget === "wasm",
+		sourceMappingURL,
 	});
 }
 
@@ -291,17 +358,23 @@ function spliceFacade(merged, facade) {
 }
 
 // Root compiles only: link every registered unit into app.wasm and splice the
-// facade into the merged bundle.  Returns `{ wasm, wat }` (nulls when there
-// is nothing to link).
-function linkIntoBundle(options, merged, pkgTarget) {
-	if (options.isDependency) return { wasm: null, wat: null };
+// facade into the merged bundle.  Returns `{ wasm, wat, sourceMapInfo }`
+// (nulls when there is nothing to link).
+function linkIntoBundle(options, merged, pkgTarget, { sourceMappingURL } = {}) {
+	const none = { wasm: null, wat: null, sourceMapInfo: null };
+	if (options.isDependency) return none;
 	const linked = linkWasmUnits(options.wasmUnits, {
 		emitWat: options.emitWat,
 		rootTarget: pkgTarget,
+		sourceMappingURL,
 	});
-	if (!linked) return { wasm: null, wat: null };
+	if (!linked) return none;
 	spliceFacade(merged, linked.facade);
-	return { wasm: linked.wasm, wat: linked.wat ?? null };
+	return {
+		wasm: linked.wasm,
+		wat: linked.wat ?? null,
+		sourceMapInfo: linked.sourceMapInfo ?? null,
+	};
 }
 
 // ── Import resolution ─────────────────────────────────────────
@@ -309,7 +382,7 @@ function linkIntoBundle(options, merged, pkgTarget) {
 // Shared by compileFiles (multi-file) and the single-file path in index.js.
 // Mutates checker, jsImports, bundledPackages, and preambles in place.
 
-export function resolveImports(
+function resolveImports(
 	programs,
 	fromFile,
 	checker,
@@ -350,6 +423,11 @@ export function resolveImports(
 							"package 'gom' is not available in wasm packages",
 							impNode,
 						);
+					} else if (path === "gofront/shared" && pkgTarget === "both") {
+						checker.err(
+							"'gofront/shared' requires a wasm-only package (//gofront:target wasm): a both package has no linear memory on the JS side",
+							impNode,
+						);
 					} else if (!isLocalPath(path)) {
 						if (!isBuiltinPackage(path)) {
 							checker.recordBlocker("js: import", path);
@@ -472,6 +550,7 @@ export function resolveImports(
 					nameUsed,
 					dep.exportedSymbols,
 					dep.exportedTypes,
+					dep.target,
 				);
 				checker.trackImport(nameUsed, { _line }, p._filename, p._source);
 			}
@@ -481,6 +560,29 @@ export function resolveImports(
 
 // ── Main entry points ─────────────────────────────────────────
 
+// Package target after build-time overrides (Task H6.3): `forceTarget`
+// (`--js-only`) compiles every package to JS; `targetOverrides` maps package
+// directories relative to the root source dir (`"engine/physics"`, `"."` for
+// the root) to a target, replacing the `//gofront:target` directive.
+const PACKAGE_TARGETS = new Set(["js", "wasm", "both"]);
+
+export function resolvePackageTarget(declared, pkgDir, options = {}) {
+	if (options.forceTarget) return options.forceTarget;
+	const overrides = options.targetOverrides;
+	if (!overrides || !options.rootDir) return declared;
+	const rel = relative(resolve(options.rootDir), resolve(pkgDir))
+		.split(sep)
+		.join("/");
+	const key = rel === "" ? "." : rel;
+	const t = overrides[key] ?? (key === "." ? overrides[""] : undefined);
+	if (t === undefined) return declared;
+	if (!PACKAGE_TARGETS.has(t))
+		throw new Error(
+			`gofront.json: invalid target '${t}' for package '${key}' (expected js, wasm or both)`,
+		);
+	return t;
+}
+
 export function compileSingleFile(inputPath, options = {}) {
 	const {
 		sourceMap = false,
@@ -502,6 +604,7 @@ export function compileSingleFile(inputPath, options = {}) {
 
 	const ast = new Parser(tokens, basename(inputPath), source).parse();
 	ast._source = source;
+	ast._path = resolve(inputPath);
 	if (dumpAst) return { ast };
 
 	const outputDir =
@@ -513,7 +616,11 @@ export function compileSingleFile(inputPath, options = {}) {
 	const bundledPackages = new Set();
 	const preambles = [];
 
-	const pkgTarget = ast.target ?? options.target ?? "js";
+	const pkgTarget = resolvePackageTarget(
+		ast.target ?? options.target ?? "js",
+		dirname(resolve(inputPath)),
+		options,
+	);
 	ast.target = pkgTarget;
 	checker.target = pkgTarget;
 	checker.pkgName = ast.pkg?.name ?? "main";
@@ -534,6 +641,7 @@ export function compileSingleFile(inputPath, options = {}) {
 	if (errors.length > 0) {
 		throw new Error(errors.map((e) => e.message).join("\n"));
 	}
+	for (const w of checker.warnings) log.warn(w);
 
 	if (pkgTarget === "wasm" || pkgTarget === "both") {
 		registerWasmUnit(options, {
@@ -562,13 +670,26 @@ export function compileSingleFile(inputPath, options = {}) {
 	};
 
 	const merged = mergeCompilationChunks([...preambles, mainChunk]);
-	const { wasm, wat } = linkIntoBundle(options, merged, pkgTarget);
+	const { wasm, wat, wasmOptInfo, wasmSourceMap } = finishWasm(
+		{ ...options, sourceMap },
+		merged,
+		pkgTarget,
+		outputDir,
+	);
 
 	if (sourceMap && !options.isDependency) {
 		attachSourceMap(merged, outputDir);
 	}
 
-	return { js: merged.js, css: cg.getCss(), target: pkgTarget, wasm, wat };
+	return {
+		js: merged.js,
+		css: cg.getCss(),
+		target: pkgTarget,
+		wasm,
+		wat,
+		wasmOptInfo,
+		wasmSourceMap,
+	};
 }
 
 export function compileDir(dir, options = {}) {
@@ -591,8 +712,12 @@ export function compilePackageTestsWasm(dir, options = {}) {
 }
 
 export function compileFiles(files, options = {}) {
-	options = { ...options, wasmUnits: options.wasmUnits ?? [] };
 	const fromDir = options.fromDir ?? dirname(resolve(files[0]));
+	options = {
+		...options,
+		wasmUnits: options.wasmUnits ?? [],
+		rootDir: options.rootDir ?? fromDir,
+	};
 	const outputDir =
 		options.outputDir ??
 		(options.outputFile ? dirname(resolve(options.outputFile)) : fromDir);
@@ -622,9 +747,10 @@ export function compileFiles(files, options = {}) {
 	// Validate target directives across files in this package
 	const declaredTargets = new Map();
 	for (const p of programs) {
-		if (p.target) {
-			if (!declaredTargets.has(p.target)) declaredTargets.set(p.target, []);
-			declaredTargets.get(p.target).push(p._filename);
+		const declared = p._declaredTarget;
+		if (declared) {
+			if (!declaredTargets.has(declared)) declaredTargets.set(declared, []);
+			declaredTargets.get(declared).push(p._filename);
 		}
 	}
 	if (declaredTargets.size > 1) {
@@ -635,10 +761,13 @@ export function compileFiles(files, options = {}) {
 			`Conflicting //gofront:target directives in package '${pkgName}': ${list}`,
 		);
 	}
-	const pkgTarget =
+	const pkgTarget = resolvePackageTarget(
 		declaredTargets.size === 1
 			? declaredTargets.keys().next().value
-			: (options.target ?? "js");
+			: (options.target ?? "js"),
+		fromDir,
+		options,
+	);
 	for (const p of programs) p.target = pkgTarget;
 
 	// ── 2. Resolve imports ────────────────────────────────────────
@@ -668,6 +797,7 @@ export function compileFiles(files, options = {}) {
 		const msgs = errors.map((e) => e.message).join("\n");
 		throw new Error(msgs);
 	}
+	for (const w of checker.warnings) log.warn(w);
 
 	// ── 4. Code generation ────────────────────────────────────────
 	const emitTarget = registerPackageUnit(options, {
@@ -693,13 +823,18 @@ 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(),
 	};
 
 	const merged = mergeCompilationChunks([...preambles, mainChunk]);
-	const { wasm, wat } = linkIntoBundle(options, merged, pkgTarget);
+	const { wasm, wat, wasmOptInfo, wasmSourceMap } = finishWasm(
+		options,
+		merged,
+		pkgTarget,
+		outputDir,
+	);
 
 	if (options.sourceMap && !options.isDependency) {
 		attachSourceMap(merged, outputDir);
@@ -717,6 +852,8 @@ export function compileFiles(files, options = {}) {
 		css: allCss,
 		wasm,
 		wat,
+		wasmOptInfo,
+		wasmSourceMap,
 		programs,
 		exportedSymbols: checker.getExportedSymbols(),
 		exportedTypes: checker.getExportedTypes(),

package/src/dts-parser.js

@@ -109,10 +109,9 @@ export class DtsParser {
 
 	readIdent() {
 		this.skip();
-		let s = "";
-		while (!this.eof() && /[a-zA-Z0-9_$]/.test(this.ch()))
-			s += this.src[this.pos++];
-		return s;
+		const start = this.pos;
+		while (!this.eof() && /[a-zA-Z0-9_$]/.test(this.ch())) this.pos++;
+		return this.src.slice(start, this.pos);
 	}
 
 	consume(ch) {
@@ -171,14 +170,14 @@ export class DtsParser {
 	}
 
 	_trackBracketDepth(c, depths) {
-		const open = { "<": 0, "(": 1, "[": 2, "{": 3 };
-		const close = { ">": 0, ")": 1, "]": 2, "}": 3 };
-		if (c in open) {
-			depths[open[c]]++;
+		const oi = "<([{".indexOf(c);
+		if (oi >= 0) {
+			depths[oi]++;
 			return true;
 		}
-		if (c in close && depths[close[c]] > 0) {
-			depths[close[c]]--;
+		const ci = ">)]}".indexOf(c);
+		if (ci >= 0 && depths[ci] > 0) {
+			depths[ci]--;
 			return true;
 		}
 		return false;
@@ -392,7 +391,7 @@ export class DtsParser {
 		}
 	}
 
-	_parseMemberFuncDecl(out) {
+	_parseFuncDecl() {
 		const name = this.readIdent();
 		this.skipGenerics();
 		const params = this.parseParams();
@@ -403,12 +402,14 @@ export class DtsParser {
 			ret = this.parseType();
 		}
 		this.consume(";");
-		if (name)
-			out[name] = {
+		return {
+			name,
+			val: {
 				kind: "func",
 				params: params.map((p) => p.type),
 				returns: [ret],
-			};
+			},
+		};
 	}
 
 	_parseMemberNewSig() {
@@ -422,7 +423,7 @@ export class DtsParser {
 		this.consume(";");
 	}
 
-	_parseMemberTypeDecl(out) {
+	_parseTypeDecl() {
 		const name = this.readIdent();
 		this.skipGenerics();
 		this.skip();
@@ -432,10 +433,10 @@ export class DtsParser {
 			type = this.parseType();
 		}
 		this.consume(";");
-		if (name) out[name] = type;
+		return { name, type };
 	}
 
-	_parseMemberClassDecl(out) {
+	_parseClassDecl() {
 		const name = this.readIdent();
 		this.skipGenerics();
 		while (!this.eof() && this.ch() !== "{") this.pos++;
@@ -443,10 +444,20 @@ export class DtsParser {
 		const body = this.parseBody();
 		this.consume("}");
 		this.consume(";");
-		if (name) out[name] = { kind: "namespace", name, members: body };
+		return { name, ns: { kind: "namespace", name, members: body } };
+	}
+
+	_parseNamespaceDecl() {
+		const name = this.readIdent() || this._readStringLit();
+		this.skip();
+		this.consume("{");
+		const body = this.parseBody();
+		this.consume("}");
+		this.consume(";");
+		return { name, ns: { kind: "namespace", name, members: body } };
 	}
 
-	_parseMemberVarDecl(out) {
+	_parseVarDecl() {
 		const name = this.readIdent();
 		this.skip();
 		this.consume("?");
@@ -461,7 +472,7 @@ export class DtsParser {
 			this.skipTypeExpr();
 		}
 		this.consume(";");
-		if (name) out[name] = type;
+		return { name, type };
 	}
 
 	_parseMember(out) {
@@ -477,28 +488,29 @@ export class DtsParser {
 		}
 		this.skip();
 		switch (kw) {
-			case "function":
-				this._parseMemberFuncDecl(out);
+			case "function": {
+				const { name, val } = this._parseFuncDecl();
+				if (name) out[name] = val;
 				break;
+			}
 			case "new":
 				this._parseMemberNewSig();
 				break;
-			case "type":
-				this._parseMemberTypeDecl(out);
+			case "type": {
+				const { name, type } = this._parseTypeDecl();
+				if (name) out[name] = type;
 				break;
+			}
 			case "interface":
-			case "class":
-				this._parseMemberClassDecl(out);
+			case "class": {
+				const { name, ns } = this._parseClassDecl();
+				if (name) out[name] = ns;
 				break;
+			}
 			case "namespace":
 			case "module": {
-				const name = this.readIdent() || this._readStringLit();
-				this.skip();
-				this.consume("{");
-				const body = this.parseBody();
-				this.consume("}");
-				this.consume(";");
-				if (name) out[name] = { kind: "namespace", name, members: body };
+				const { name, ns } = this._parseNamespaceDecl();
+				if (name) out[name] = ns;
 				break;
 			}
 			case "enum": {
@@ -509,9 +521,11 @@ export class DtsParser {
 			}
 			case "const":
 			case "let":
-			case "var":
-				this._parseMemberVarDecl(out);
+			case "var": {
+				const { name, type } = this._parseVarDecl();
+				if (name) out[name] = type;
 				break;
+			}
 			default:
 				this._parseMemberDefault(kw, out);
 				break;
@@ -550,13 +564,15 @@ export class DtsParser {
 			this.consume(";");
 		}
 	}
+
 	_readStringLit() {
 		this.skip();
 		const c = this.ch();
 		if (c !== '"' && c !== "'") return null;
 		this.pos++;
-		let s = "";
-		while (!this.eof() && this.ch() !== c) s += this.src[this.pos++];
+		const start = this.pos;
+		while (!this.eof() && this.ch() !== c) this.pos++;
+		const s = this.src.slice(start, this.pos);
 		this.pos++;
 		return s;
 	}
@@ -612,85 +628,6 @@ export class DtsParser {
 		return { types, values };
 	}
 
-	_parseTopLevelTypeAlias(types) {
-		const name = this.readIdent();
-		this.skipGenerics();
-		this.skip();
-		let type = ANY;
-		if (this.ch() === "=") {
-			this.pos++;
-			type = this.parseType();
-		}
-		this.consume(";");
-		if (name) types.set(name, type);
-	}
-
-	_parseTopLevelClassDecl(kw, types, values) {
-		const name = this.readIdent();
-		this.skipGenerics();
-		while (!this.eof() && this.ch() !== "{") this.pos++;
-		this.consume("{");
-		const body = this.parseBody();
-		this.consume("}");
-		this.consume(";");
-		if (name) {
-			const ns = { kind: "namespace", name, members: body };
-			types.set(name, ns);
-			if (kw === "class") values.set(name, ns);
-		}
-	}
-
-	_parseTopLevelNamespaceDecl(types, values) {
-		const name = this.readIdent() || this._readStringLit();
-		this.skip();
-		this.consume("{");
-		const body = this.parseBody();
-		this.consume("}");
-		this.consume(";");
-		if (name) {
-			const ns = { kind: "namespace", name, members: body };
-			types.set(name, ns);
-			values.set(name, ns);
-		}
-	}
-
-	_parseTopLevelFuncDecl(values) {
-		const name = this.readIdent();
-		this.skipGenerics();
-		const params = this.parseParams();
-		this.skip();
-		let ret = VOID;
-		if (this.ch() === ":") {
-			this.pos++;
-			ret = this.parseType();
-		}
-		this.consume(";");
-		if (name)
-			values.set(name, {
-				kind: "func",
-				params: params.map((p) => p.type),
-				returns: [ret],
-			});
-	}
-
-	_parseTopLevelVarDecl(values) {
-		const name = this.readIdent();
-		this.skip();
-		this.consume("?");
-		let type = ANY;
-		if (this.ch() === ":") {
-			this.pos++;
-			type = this.parseType();
-		}
-		this.skip();
-		if (this.ch() === "=") {
-			this.pos++;
-			this.skipTypeExpr();
-		}
-		this.consume(";");
-		if (name) values.set(name, type);
-	}
-
 	_parseTopLevelDecl(kw, types, values) {
 		switch (kw) {
 			case "import":
@@ -698,17 +635,29 @@ export class DtsParser {
 				this.skipTypeExpr();
 				this.consume(";");
 				break;
-			case "type":
-				this._parseTopLevelTypeAlias(types);
+			case "type": {
+				const { name, type } = this._parseTypeDecl();
+				if (name) types.set(name, type);
 				break;
+			}
 			case "interface":
-			case "class":
-				this._parseTopLevelClassDecl(kw, types, values);
+			case "class": {
+				const { name, ns } = this._parseClassDecl();
+				if (name) {
+					types.set(name, ns);
+					if (kw === "class") values.set(name, ns);
+				}
 				break;
+			}
 			case "namespace":
-			case "module":
-				this._parseTopLevelNamespaceDecl(types, values);
+			case "module": {
+				const { name, ns } = this._parseNamespaceDecl();
+				if (name) {
+					types.set(name, ns);
+					values.set(name, ns);
+				}
 				break;
+			}
 			case "enum": {
 				const name = this.readIdent();
 				this.skipBlock();
@@ -719,14 +668,18 @@ export class DtsParser {
 				}
 				break;
 			}
-			case "function":
-				this._parseTopLevelFuncDecl(values);
+			case "function": {
+				const { name, val } = this._parseFuncDecl();
+				if (name) values.set(name, val);
 				break;
+			}
 			case "const":
 			case "let":
-			case "var":
-				this._parseTopLevelVarDecl(values);
+			case "var": {
+				const { name, type } = this._parseVarDecl();
+				if (name) values.set(name, type);
 				break;
+			}
 			default:
 				this.skipTypeExpr();
 				this.consume(";");