gofront 1.7.0 → 1.9.0

package/src/index.js

@@ -14,30 +14,30 @@
 //   gofront init [dir]             — scaffold a new GoFront project
 
 import { statSync } from "node:fs";
-import { dirname, relative, resolve } from "node:path";
-import { copyAssets } from "./asset-manager.js";
+import { dirname, resolve } from "node:path";
 import {
-	formatBuildSummary,
+	devReporters,
 	formatPrepSummary,
 	formatWrittenDesc,
 	GOFRONT_VERSION,
+	HELP_TEXT,
 	handleBuild,
 	handleCheck,
 	handleDev,
 	handleInit,
 	handlePrep,
 	handleTest,
-	maybeMinify,
 	parseBuildArgs,
 	parseCheckArgs,
 	parseDevArgs,
 	parseLegacyArgs,
 	parsePrepArgs,
 	parseTestArgs,
-	runCompile,
-	writeCompileOutput,
-} from "./cli-core.js";
-import { colors, formatDiagnostic, log, ms, stamp } from "./colors.js";
+	reportBuild,
+	reportCheck,
+	runSingleShot,
+} from "./cli/cli-core.js";
+import { colors, log, stamp } from "./cli/colors.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
 
@@ -48,35 +48,7 @@ if (args[0] === "--version" || args[0] === "-v") {
 }
 
 if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-	console.log(
-		`
-GoFront — a Go-inspired language that compiles to JavaScript and WebAssembly
-
-Usage:
-  gofront dev [dir] [options]    Start dev server with live reload (default port 3000)
-  gofront build [dir] [options]  Build production bundle (-o <dir>, --pwa, --minify, --emit-wat, --release, --wasm-opt, --js-only)
-  gofront check [dir|dir/...]    Type-check only (dir/... recurses into every package)
-  gofront test [dir|dir/...] [--dom]  Run unit tests (-v verbose, -run <regex>)
-  gofront prep [dir] [--minify]  Copy static assets and bundle vendor dependencies
-  gofront init [dir]             Scaffold a new GoFront project
-  gofront <file.go>              Compile single file and print to stdout
-  gofront <dir>  (or gofront .)  Compile all *.go in directory as one bundle
-  gofront <input> -o out.js      Compile and write to file (wasm packages also emit app.wasm)
-  gofront <input> --release      Production build with minification and Binaryen wasm optimization
-  gofront <input> --wasm-opt     Optimize wasm output with Binaryen (-O3 + GUFA)
-  gofront <input> --check        Type-check only
-  gofront <input> --watch        Watch for changes and recompile
-  gofront <input> -o out.js --serve          Watch + serve with live reload (default port 3000)
-  gofront <input> -o out.js --serve --port 8080  Use a custom port
-  gofront <input> -o out.js --copy-assets    Compile and synchronize static assets
-  gofront <input> --source-map   Append inline source map to output
-  gofront <input> --minify       Minify output
-  gofront <input> --minify --mangle  Minify and mangle identifiers
-  gofront <file.go> --ast        Dump AST (debug)
-  gofront <file.go> --tokens     Dump tokens (debug)
-  gofront --version              Print version
-`.trim(),
-	);
+	console.log(HELP_TEXT);
 	process.exit(0);
 }
 
@@ -131,19 +103,7 @@ if (args[0] === "test") {
 if (args[0] === "check") {
 	const { targetDir, forceTarget } = parseCheckArgs(args.slice(1));
 	try {
-		const { elapsedMs, packages } = handleCheck(targetDir, { forceTarget });
-		const okLine = (label, t) =>
-			log.info(`${colors.cyan(label)} — ${colors.green("OK")} ${ms(t)}`);
-		if (packages) {
-			for (const pkg of packages) {
-				okLine(relative(process.cwd(), pkg.dir) || ".", pkg.elapsedMs);
-			}
-			log.info(
-				`${colors.bold(`${packages.length} packages`)} — ${colors.bold(colors.green("OK"))} ${ms(elapsedMs)}`,
-			);
-		} else {
-			okLine(targetDir, elapsedMs);
-		}
+		reportCheck(handleCheck(targetDir, { forceTarget }), targetDir);
 		process.exit(0);
 	} catch (e) {
 		log.fail(e.message);
@@ -157,13 +117,7 @@ if (args[0] === "build") {
 	const buildOptions = parseBuildArgs(args.slice(1));
 	try {
 		const result = await handleBuild(buildOptions.targetDir, buildOptions);
-		for (const line of formatBuildSummary(result)) {
-			log.info(
-				line
-					.replace(/^build complete/, colors.green("build complete"))
-					.replace(/\(([\d.]+ kB)\)$/, (_, s) => colors.dim(`(${s})`)),
-			);
-		}
+		reportBuild(result);
 		process.exit(0);
 	} catch (e) {
 		log.fail(e.message);
@@ -200,22 +154,19 @@ if (args[0] === "dev") {
 	}
 }
 
+const flags = parseLegacyArgs(args);
 const {
 	inputArg,
 	outputFile,
-	checkOnly,
-	dumpAst,
-	dumpTokens,
 	sourceMap,
 	serve: serveMode,
 	watch: watchMode,
 	copyAssets: copyAssetsFlag,
-	wasmOpt,
 	minify: minifyOutput,
 	mangle: mangleOutput,
 	port: servePort,
 	forceTarget,
-} = parseLegacyArgs(args);
+} = flags;
 
 // ── Determine input mode ─────────────────────────────────────
 
@@ -228,96 +179,10 @@ try {
 	process.exit(1);
 }
 
-function copyProjectAssets(verbose) {
-	try {
-		const { copied, skipped } = copyAssets(resolve("."));
-		if (verbose && (copied > 0 || skipped > 0)) {
-			log.info(`copied ${copied} assets (${skipped} skipped)`);
-		}
-	} catch (e) {
-		log.warn(`asset copy failed: ${e.message}`);
-	}
-}
-
 // ── Single-shot mode ─────────────────────────────────────────
 
 if (!watchMode) {
-	let result;
-	const startMs = performance.now();
-	try {
-		result = runCompile(inputPath, isDir, {
-			sourceMap,
-			outputFile,
-			dumpTokens,
-			dumpAst,
-			wasmOpt,
-			forceTarget,
-		});
-	} catch (e) {
-		log.fail(e.message);
-		process.exit(1);
-	}
-
-	if (result.tokens) {
-		for (const tok of result.tokens) console.log(tok.toString());
-		process.exit(0);
-	}
-	if (result.ast) {
-		console.log(JSON.stringify(result.ast, null, 2));
-		process.exit(0);
-	}
-
-	if (checkOnly) {
-		const elapsedMs = (performance.now() - startMs).toFixed(0);
-		log.info(
-			`${colors.cyan(inputArg)} — ${colors.green("OK")} ${ms(elapsedMs)}`,
-		);
-		process.exit(0);
-	}
-
-	let js;
-	try {
-		js = maybeMinify(result.js, {
-			minify: minifyOutput,
-			mangle: mangleOutput,
-			sourceMap,
-		});
-	} catch (e) {
-		log.fail(`minify failed: ${e.message}`);
-		process.exit(1);
-	}
-
-	const elapsedMs = (performance.now() - startMs).toFixed(0);
-
-	if (outputFile) {
-		try {
-			const written = writeCompileOutput(resolve(outputFile), result, js);
-			log.info(
-				`wrote ${formatWrittenDesc(written, outputFile)} ${ms(elapsedMs)}`,
-			);
-			if (result.wasmOptInfo && result.wasmOptInfo.originalSize > 0) {
-				const origKb = (result.wasmOptInfo.originalSize / 1024).toFixed(1);
-				const optKb = (result.wasmOptInfo.optimizedSize / 1024).toFixed(1);
-				log.info(
-					`wasm-opt: app.wasm ${origKb} kB → ${optKb} kB (-${result.wasmOptInfo.percentSaved}%) [${result.wasmOptInfo.engine}]`,
-				);
-			}
-		} catch (e) {
-			log.fail(`cannot write '${outputFile}': ${e.message}`);
-			process.exit(1);
-		}
-	} else {
-		console.log(js);
-		if (result.wasm) {
-			log.warn(
-				"wasm packages were linked but app.wasm needs -o <file> to be written",
-			);
-		}
-	}
-
-	if (copyAssetsFlag) copyProjectAssets(true);
-
-	process.exit(0);
+	process.exit(runSingleShot(inputPath, isDir, flags));
 }
 
 // ── Watch mode ───────────────────────────────────────────────
@@ -342,26 +207,7 @@ try {
 		mangle: mangleOutput,
 		copyAssets: copyAssetsFlag,
 		forceTarget,
-		onBuild: ({ js, written, elapsedMs, changedFile }) => {
-			const changeNote = changedFile ? ` — ${changedFile} changed` : "";
-			const timing = colors.dim(`(${elapsedMs}ms${changeNote})`);
-			if (outputFile) {
-				console.error(
-					`${prefix()} ${colors.green("OK")} — wrote ${formatWrittenDesc(written, outputFile)} ${timing}`,
-				);
-			} else {
-				// Clear screen then print
-				process.stdout.write("\x1Bc");
-				console.log(js);
-				console.error(`${prefix()} ${colors.green("OK")} ${timing}`);
-			}
-			if (copyAssetsFlag) copyProjectAssets(false);
-		},
-		onError: (e) => {
-			console.error(`${prefix()} ${colors.bold(colors.red("ERROR"))}`);
-			for (const line of formatDiagnostic(e.message).split("\n"))
-				console.error(`  ${line}`);
-		},
+		...devReporters({ outputFile, copyAssets: copyAssetsFlag }),
 	});
 } catch (e) {
 	log.fail(e.message);

package/src/{lexer.js → lexer/lexer.js}

@@ -52,8 +52,8 @@ const KEYWORDS = new Set([
 	"case",
 	"default",
 	"map",
-	"new",
 	"fallthrough",
+	"goto",
 	"defer",
 	"async",
 	"await",
@@ -86,6 +86,11 @@ const ASSIGN_OP = {
 	":": [T.DEFINE, ":=", T.COLON, ":"],
 };
 
+const UNICODE_LETTER = /^\p{L}$/u;
+const UNICODE_DIGIT = /^\p{Nd}$/u;
+const isUnicodeLetter = (cp) => UNICODE_LETTER.test(String.fromCodePoint(cp));
+const isUnicodeDigit = (cp) => UNICODE_DIGIT.test(String.fromCodePoint(cp));
+
 export class LexError extends Error {
 	constructor(msg, line, col, filename, sourceCode) {
 		const loc = filename ? `${filename}:${line}:${col}` : `${line}:${col}`;
@@ -103,6 +108,42 @@ export class LexError extends Error {
 	}
 }
 
+const SIMPLE_ESCAPES = {
+	a: 7,
+	b: 8,
+	f: 12,
+	n: 10,
+	r: 13,
+	t: 9,
+	v: 11,
+	"\\": 92,
+};
+
+// Decodes the raw bytes of consecutive \xNN / octal escapes in a string
+// literal: valid UTF-8 sequences become their code point, every other byte
+// 0x80-0xff becomes the lone surrogate U+DC00+byte so the runtime can turn it
+// back into that byte when the string is converted to []byte.
+function decodeRawBytes(bytes) {
+	const dec = new TextDecoder("utf-8", { fatal: true });
+	let out = "";
+	for (let i = 0; i < bytes.length; ) {
+		const b = bytes[i];
+		const n = b < 0x80 ? 1 : b >= 0xf0 ? 4 : b >= 0xe0 ? 3 : b >= 0xc0 ? 2 : 0;
+		if (n > 0 && i + n <= bytes.length) {
+			try {
+				out += dec.decode(Uint8Array.from(bytes.slice(i, i + n)));
+				i += n;
+				continue;
+			} catch {
+				// invalid sequence: fall through to the lone-byte case
+			}
+		}
+		out += String.fromCharCode(b < 0x80 ? b : 0xdc00 + b);
+		i++;
+	}
+	return out;
+}
+
 export class Lexer {
 	constructor(source, filename = null) {
 		this.src = source;
@@ -113,6 +154,9 @@ export class Lexer {
 		this.filename = filename;
 		this.target = null;
 		this.targetDirective = null;
+		this.intrinsics = new Map(); // line -> name of a //gofront:intrinsic
+		this.natives = new Map(); // line -> name of a //gofront:native
+		this.embedDirectives = []; // {line, col} of each //go:embed line comment
 	}
 
 	// ── Primitives ──────────────────────────────────────────────
@@ -158,6 +202,18 @@ export class Lexer {
 				while (this.pos < this.src.length && this.peek() !== "\n")
 					this.advance();
 				const comment = this.src.slice(start, this.pos);
+				if (
+					/^\/\/go:embed(?:\s|$)/.test(comment) &&
+					/^[ \t]*$/.test(
+						this.src.slice(this.src.lastIndexOf("\n", start - 1) + 1, start),
+					)
+				)
+					this.embedDirectives.push({ line, col });
+				const intrinsic = comment.match(/^\/\/gofront:intrinsic\s+(\S+)/);
+				if (intrinsic) this.intrinsics.set(line, intrinsic[1]);
+				const native = comment.match(/^\/\/gofront:native\s+(\S+)/);
+				if (native) this.natives.set(line, native[1]);
+				if (!intrinsic && !native) this.forwardDirectives(line, start);
 				const match = comment.match(/^\/\/gofront:target\s+(\S+)/);
 				if (match) {
 					this.target = match[1];
@@ -222,29 +278,7 @@ export class Lexer {
 				if (parts === null) parts = [];
 				if (this.pos > start) parts.push(this.src.slice(start, this.pos));
 				this.advance(); // skip \
-				const esc = this.advance();
-				switch (esc) {
-					case "n":
-						parts.push("\n");
-						break;
-					case "t":
-						parts.push("\t");
-						break;
-					case "r":
-						parts.push("\r");
-						break;
-					case '"':
-						parts.push('"');
-						break;
-					case "\\":
-						parts.push("\\");
-						break;
-					case "0":
-						parts.push("\0");
-						break;
-					default:
-						parts.push(`\\${esc}`);
-				}
+				parts.push(this.readStringEscape());
 				start = this.pos;
 			} else {
 				this.advance();
@@ -253,6 +287,77 @@ export class Lexer {
 		throw new LexError("Unterminated string", l, c, this.filename, this.src);
 	}
 
+	// The escape after a consumed backslash in a string literal.  \xNN and octal
+	// escapes are raw bytes; a run of them is decoded together so "\xc3\xa9" is
+	// "é" and "\xff" is one invalid byte (a lone surrogate, see decodeRawBytes).
+	readStringEscape() {
+		if (!this.isByteEscapeAt(this.pos))
+			return String.fromCodePoint(this.readEscape('"'));
+		const bytes = [this.readEscape('"')];
+		while (this.peek() === "\\" && this.isByteEscapeAt(this.pos + 1)) {
+			this.advance();
+			bytes.push(this.readEscape('"'));
+		}
+		return decodeRawBytes(bytes);
+	}
+
+	// A doc comment between a directive and its func carries the directive down
+	// so the parser still finds it on the line above the func.
+	forwardDirectives(line, start) {
+		const before = this.src.slice(
+			this.src.lastIndexOf("\n", start - 1) + 1,
+			start,
+		);
+		if (!/^[ \t]*$/.test(before)) return;
+		for (const map of [this.intrinsics, this.natives])
+			if (map.has(line - 1)) map.set(line, map.get(line - 1));
+	}
+
+	isByteEscapeAt(i) {
+		const n = this.src[i];
+		return n === "x" || (n >= "0" && n <= "7");
+	}
+
+	// Reads the escape after a consumed backslash and returns its code point.
+	// `quote` is the enclosing delimiter: `\'` is valid only in runes and
+	// `\"` only in strings. `\xNN` and octal escapes give 0-255 (a code point in
+	// rune literals; string literals decode runs of them as UTF-8 bytes).
+	readEscape(quote) {
+		const l = this.line,
+			c = this.col;
+		const fail = (msg) => {
+			throw new LexError(msg, l, c, this.filename, this.src);
+		};
+		const esc = this.advance();
+		const simple = SIMPLE_ESCAPES[esc];
+		if (simple !== undefined) return simple;
+		if (esc === quote) return esc.charCodeAt(0);
+		if (esc === "x") return this.readEscapeDigits(2, 16, fail);
+		if (esc === "u" || esc === "U") {
+			const v = this.readEscapeDigits(esc === "u" ? 4 : 8, 16, fail);
+			if (v > 0x10ffff || (v >= 0xd800 && v < 0xe000))
+				fail("escape is invalid Unicode code point");
+			return v;
+		}
+		if (esc >= "0" && esc <= "7") {
+			const v = Number(esc) * 64 + this.readEscapeDigits(2, 8, fail);
+			if (v > 255) fail("octal escape value exceeds 255");
+			return v;
+		}
+		return fail(`unknown escape sequence: \\${esc}`);
+	}
+
+	readEscapeDigits(n, radix, fail) {
+		let v = 0;
+		for (let i = 0; i < n; i++) {
+			const d = Number.parseInt(this.src[this.pos] ?? "", radix);
+			if (Number.isNaN(d)) fail("invalid character in escape sequence");
+			v = v * radix + d;
+			this.advance();
+		}
+		return v;
+	}
+
 	readRawString() {
 		const l = this.line,
 			c = this.col;
@@ -279,38 +384,11 @@ export class Lexer {
 		let code;
 		if (this.peek() === "\\") {
 			this.advance();
-			const esc = this.advance();
-			switch (esc) {
-				case "n":
-					code = 10;
-					break;
-				case "t":
-					code = 9;
-					break;
-				case "r":
-					code = 13;
-					break;
-				case "'":
-					code = 39;
-					break;
-				case "\\":
-					code = 92;
-					break;
-				case "0":
-					code = 0;
-					break;
-				default:
-					throw new LexError(
-						`Unknown escape in rune literal: \\${esc}`,
-						l,
-						c,
-						this.filename,
-						this.src,
-					);
-			}
+			code = this.readEscape("'");
 		} else if (this.peek() !== "'") {
 			code = this.src.codePointAt(this.pos);
 			this.advance();
+			if (code > 0xffff) this.pos++; // astral: skip the low surrogate
 		} else {
 			throw new LexError("Empty rune literal", l, c, this.filename, this.src);
 		}
@@ -392,6 +470,20 @@ export class Lexer {
 		return { n, isFloat: false };
 	}
 
+	// The leading "." is already consumed; reads digits and an optional exponent.
+	_readLeadingDotFloat() {
+		let n = "0.";
+		while (this.pos < this.src.length) {
+			const c = this.src.charCodeAt(this.pos);
+			if (c >= 48 && c <= 57) n += this.advance();
+			else if (c === 95) this.advance();
+			else break;
+		}
+		const c = this.src.charCodeAt(this.pos);
+		if (c === 101 || c === 69) n = this._readDecimalExponent(n);
+		return { n };
+	}
+
 	_readDecimalExponent(n) {
 		n += this.advance(); // consume e/E
 		if (this.peek() === "+" || this.peek() === "-") n += this.advance();
@@ -420,12 +512,10 @@ export class Lexer {
 				break;
 			}
 		}
-		if (
-			this.pos + 1 < this.src.length &&
-			this.src.charCodeAt(this.pos) === 46
-		) {
+		if (this.src.charCodeAt(this.pos) === 46) {
+			// `1.` is a float literal; `1..` and `1.x` keep the dot separate.
 			const next = this.src.charCodeAt(this.pos + 1);
-			if (next >= 48 && next <= 57) {
+			if (this._dotContinuesNumber(next)) {
 				isFloat = true;
 				n += this.advance();
 				while (this.pos < this.src.length) {
@@ -438,6 +528,7 @@ export class Lexer {
 						break;
 					}
 				}
+				if (n.endsWith(".")) n += "0";
 			}
 		}
 		if (this.pos < this.src.length) {
@@ -450,6 +541,39 @@ export class Lexer {
 		return { n, isFloat };
 	}
 
+	// Whether the "." at the cursor belongs to the decimal literal before it.
+	// `next` is the code after the dot: a digit, an exponent (`1.e3`), an
+	// imaginary suffix (`1.i`) or anything that cannot start a selector or a
+	// range-style `..` makes `1.` a float; `1.x` and `1..` keep the dot apart.
+	_dotContinuesNumber(next) {
+		if (Number.isNaN(next)) return true;
+		if (next >= 48 && next <= 57) return true;
+		if (next === 46) return false;
+		const after = this.src.charCodeAt(this.pos + 2);
+		const identAfter =
+			(after >= 97 && after <= 122) ||
+			(after >= 65 && after <= 90) ||
+			after === 95 ||
+			(after >= 48 && after <= 57);
+		if (next === 101 || next === 69) {
+			return (after >= 48 && after <= 57) || after === 43 || after === 45;
+		}
+		if (next === 105) return !identAfter;
+		return !(
+			(next >= 97 && next <= 122) ||
+			(next >= 65 && next <= 90) ||
+			next === 95 ||
+			next > 127
+		);
+	}
+
+	_startsUnicodeIdent() {
+		return (
+			this.peek().charCodeAt(0) > 127 &&
+			isUnicodeLetter(this.src.codePointAt(this.pos))
+		);
+	}
+
 	readIdent() {
 		const start = this.pos;
 		while (this.pos < this.src.length) {
@@ -461,6 +585,10 @@ export class Lexer {
 				code === 95
 			) {
 				this.pos++;
+			} else if (code > 127) {
+				const cp = this.src.codePointAt(this.pos);
+				if (!isUnicodeLetter(cp) && !isUnicodeDigit(cp)) break;
+				this.pos += cp > 0xffff ? 2 : 1;
 			} else {
 				break;
 			}
@@ -526,7 +654,7 @@ export class Lexer {
 			}
 
 			// Identifiers & keywords
-			if (/[a-zA-Z_]/.test(ch)) {
+			if (/[a-zA-Z_]/.test(ch) || this._startsUnicodeIdent()) {
 				const id = this.readIdent();
 				this.push(KEYWORDS.has(id) ? id : T.IDENT, id, l, c);
 				continue;
@@ -541,6 +669,9 @@ export class Lexer {
 		this.push(T.EOF, "", this.line, this.col);
 		this.tokens.target = this.target;
 		this.tokens.targetDirective = this.targetDirective;
+		this.tokens.intrinsics = this.intrinsics;
+		this.tokens.natives = this.natives;
+		this.tokens.embedDirectives = this.embedDirectives;
 		return this.tokens;
 	}
 	_readPlusOp(l, c) {
@@ -573,8 +704,10 @@ export class Lexer {
 
 	_readAmpOp(l, c) {
 		if (this.match("&")) this.push(T.AND, "&&", l, c);
-		else if (this.match("^")) this.push(T.AND_NOT, "&^", l, c);
-		else if (this.match("=")) this.push(T.AMP_ASSIGN, "&=", l, c);
+		else if (this.match("^")) {
+			if (this.match("=")) this.push(T.AND_NOT_ASSIGN, "&^=", l, c);
+			else this.push(T.AND_NOT, "&^", l, c);
+		} else if (this.match("=")) this.push(T.AMP_ASSIGN, "&=", l, c);
 		else this.push(T.AMP, "&", l, c);
 	}
 
@@ -614,7 +747,15 @@ export class Lexer {
 				else this.push(T.PIPE, "|", l, c);
 				break;
 			case ".":
-				if (this.peek() === "." && this.peek(1) === ".") {
+				if (/[0-9]/.test(this.peek() ?? "")) {
+					const { n } = this._readLeadingDotFloat();
+					if (this.src[this.pos] === "i") {
+						this.advance();
+						this.push(T.IMAG, n, l, c);
+					} else {
+						this.push(T.FLOAT, n, l, c);
+					}
+				} else if (this.peek() === "." && this.peek(1) === ".") {
 					this.advance();
 					this.advance();
 					this.push(T.ELLIPSIS, "...", l, c);