gofront 1.6.0 → 1.7.0

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;
@@ -204,9 +203,48 @@ export class DtsParser {
 
 	// ── Type parsing ─────────────────────────────────────────────
 
+	_parseTupleElement() {
+		this.skip();
+		if (this.startsWith("...")) this.pos += 3;
+
+		const savedPos = this.pos;
+		const ident = this.readIdent();
+		if (ident) {
+			this.skip();
+			if (this.ch() === "?") {
+				this.pos++;
+				this.skip();
+			}
+			if (this.ch() === ":") {
+				this.pos++;
+				return this.parseType(false);
+			}
+		}
+		this.pos = savedPos;
+		return this.parseType(false);
+	}
+
+	_parseTupleType(inReturn) {
+		this.consume("[");
+		const elements = [];
+		while (!this.eof() && this.peek() !== "]") {
+			this.skip();
+			if (this.ch() === "]") break;
+			elements.push(this._parseTupleElement());
+			this.skip();
+			if (this.ch() !== ",") break;
+			this.pos++;
+		}
+		this.consume("]");
+		if (inReturn) {
+			return { kind: "tuple", types: elements };
+		}
+		return { kind: "slice", elem: ANY };
+	}
+
 	// Parse a TypeScript type expression and return a GoFront type.
 	// Always returns something; falls back to ANY for complex types.
-	parseType() {
+	parseType(inReturn = false) {
 		this.skip();
 
 		// Skip modifiers
@@ -227,13 +265,16 @@ export class DtsParser {
 		this.skip();
 		if (this.ch() === "|" || this.ch() === "&") this.pos++;
 
-		let base = this._parseBaseType();
+		let base = this._parseBaseType(inReturn);
 
 		this.skip();
 		// Array suffix: T[] or T[][]
 		while (this.startsWith("[]")) {
 			this.pos += 2;
-			base = { kind: "slice", elem: base };
+			base = {
+				kind: "slice",
+				elem: base.kind === "tuple" ? { kind: "slice", elem: ANY } : base,
+			};
 			this.skip();
 		}
 
@@ -286,14 +327,11 @@ export class DtsParser {
 		return { kind: "basic", name: "any", alias: name };
 	}
 
-	_parseBaseType() {
+	_parseBaseType(inReturn = false) {
 		this.skip();
 		const c = this.ch();
 		if (c === "[") {
-			this.pos++;
-			this.skipTypeExpr("]");
-			this.consume("]");
-			return ANY;
+			return this._parseTupleType(inReturn);
 		}
 		if (c === "{") {
 			this.skipBlock();
@@ -392,7 +430,7 @@ export class DtsParser {
 		}
 	}
 
-	_parseMemberFuncDecl(out) {
+	_parseFuncDecl() {
 		const name = this.readIdent();
 		this.skipGenerics();
 		const params = this.parseParams();
@@ -400,15 +438,26 @@ export class DtsParser {
 		let ret = VOID;
 		if (this.ch() === ":") {
 			this.pos++;
-			ret = this.parseType();
+			ret = this.parseType(true);
 		}
 		this.consume(";");
-		if (name)
-			out[name] = {
+		const isVariadic = params.some((p) => p.variadic);
+		return {
+			name,
+			val: {
 				kind: "func",
-				params: params.map((p) => p.type),
-				returns: [ret],
-			};
+				params: params.map((p) =>
+					p.variadic && p.type?.kind === "slice" ? p.type.elem : p.type,
+				),
+				returns:
+					ret.kind === "tuple"
+						? ret.types.length > 0
+							? ret.types
+							: [VOID]
+						: [ret],
+				...(isVariadic ? { variadic: true } : {}),
+			},
+		};
 	}
 
 	_parseMemberNewSig() {
@@ -422,7 +471,7 @@ export class DtsParser {
 		this.consume(";");
 	}
 
-	_parseMemberTypeDecl(out) {
+	_parseTypeDecl() {
 		const name = this.readIdent();
 		this.skipGenerics();
 		this.skip();
@@ -432,10 +481,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 +492,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 } };
 	}
 
-	_parseMemberVarDecl(out) {
+	_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 } };
+	}
+
+	_parseVarDecl() {
 		const name = this.readIdent();
 		this.skip();
 		this.consume("?");
@@ -461,7 +520,7 @@ export class DtsParser {
 			this.skipTypeExpr();
 		}
 		this.consume(";");
-		if (name) out[name] = type;
+		return { name, type };
 	}
 
 	_parseMember(out) {
@@ -477,28 +536,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 +569,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;
@@ -531,13 +593,22 @@ export class DtsParser {
 			let ret = VOID;
 			if (this.ch() === ":") {
 				this.pos++;
-				ret = this.parseType();
+				ret = this.parseType(true);
 			}
 			this.consume(";");
+			const isVariadic = params.some((p) => p.variadic);
 			out[name] = {
 				kind: "func",
-				params: params.map((p) => p.type),
-				returns: [ret],
+				params: params.map((p) =>
+					p.variadic && p.type?.kind === "slice" ? p.type.elem : p.type,
+				),
+				returns:
+					ret.kind === "tuple"
+						? ret.types.length > 0
+							? ret.types
+							: [VOID]
+						: [ret],
+				...(isVariadic ? { variadic: true } : {}),
 			};
 		} else if (this.ch() === ":") {
 			this.pos++;
@@ -550,13 +621,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 +685,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 +692,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 +725,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(";");

package/src/index.js

@@ -13,11 +13,6 @@
 //   gofront <file.go> --tokens     — dump tokens of first file (debug)
 //   gofront init [dir]             — scaffold a new GoFront project
 
-import { createRequire } from "node:module";
-
-const _require = createRequire(import.meta.url);
-const { version } = _require("../package.json");
-
 import { statSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
 import { copyAssets } from "./asset-manager.js";
@@ -25,6 +20,7 @@ import {
 	formatBuildSummary,
 	formatPrepSummary,
 	formatWrittenDesc,
+	GOFRONT_VERSION,
 	handleBuild,
 	handleCheck,
 	handleDev,
@@ -47,7 +43,7 @@ import { colors, formatDiagnostic, log, ms, stamp } from "./colors.js";
 
 const args = process.argv.slice(2);
 if (args[0] === "--version" || args[0] === "-v") {
-	console.log(`gofront ${version}`);
+	console.log(`gofront ${GOFRONT_VERSION}`);
 	process.exit(0);
 }
 

package/src/lexer.js

@@ -203,11 +203,25 @@ export class Lexer {
 		const l = this.line,
 			c = this.col;
 		this.advance(); // opening "
-		const parts = [];
-		while (this.pos < this.src.length && this.peek() !== '"') {
-			if (this.peek() === "\n") this.err("Unterminated string literal");
-			if (this.peek() === "\\") {
-				this.advance();
+		let start = this.pos;
+		let parts = null;
+		while (this.pos < this.src.length) {
+			const ch = this.src[this.pos];
+			if (ch === '"') {
+				if (parts === null) {
+					const str = this.src.slice(start, this.pos);
+					this.advance(); // closing "
+					return str;
+				}
+				parts.push(this.src.slice(start, this.pos));
+				this.advance(); // closing "
+				return parts.join("");
+			}
+			if (ch === "\n") this.err("Unterminated string literal");
+			if (ch === "\\") {
+				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":
@@ -231,14 +245,12 @@ export class Lexer {
 					default:
 						parts.push(`\\${esc}`);
 				}
+				start = this.pos;
 			} else {
-				parts.push(this.advance());
+				this.advance();
 			}
 		}
-		if (this.pos >= this.src.length)
-			throw new LexError("Unterminated string", l, c, this.filename, this.src);
-		this.advance(); // closing "
-		return parts.join("");
+		throw new LexError("Unterminated string", l, c, this.filename, this.src);
 	}
 
 	readRawString() {
@@ -383,39 +395,78 @@ export class Lexer {
 	_readDecimalExponent(n) {
 		n += this.advance(); // consume e/E
 		if (this.peek() === "+" || this.peek() === "-") n += this.advance();
-		while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
-			const ch = this.advance();
-			if (ch !== "_") n += ch;
+		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;
+			}
 		}
 		return n;
 	}
 
 	_readDecimalNumber(n) {
 		let isFloat = false;
-		while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
-			const ch = this.advance();
-			if (ch !== "_") n += ch;
+		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(); // skip _
+			} else {
+				break;
+			}
 		}
-		if (this.peek() === "." && /[0-9]/.test(this.peek(1))) {
-			isFloat = true;
-			n += this.advance();
-			while (this.pos < this.src.length && /[0-9_]/.test(this.peek())) {
-				const ch = this.advance();
-				if (ch !== "_") n += ch;
+		if (
+			this.pos + 1 < this.src.length &&
+			this.src.charCodeAt(this.pos) === 46
+		) {
+			const next = this.src.charCodeAt(this.pos + 1);
+			if (next >= 48 && next <= 57) {
+				isFloat = true;
+				n += this.advance();
+				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(); // skip _
+					} else {
+						break;
+					}
+				}
 			}
 		}
-		if (this.peek() === "e" || this.peek() === "E") {
-			isFloat = true;
-			n = this._readDecimalExponent(n);
+		if (this.pos < this.src.length) {
+			const c = this.src.charCodeAt(this.pos);
+			if (c === 101 || c === 69) {
+				isFloat = true;
+				n = this._readDecimalExponent(n);
+			}
 		}
 		return { n, isFloat };
 	}
 
 	readIdent() {
-		let s = "";
-		while (this.pos < this.src.length && /[a-zA-Z0-9_]/.test(this.peek()))
-			s += this.advance();
-		return s;
+		const start = this.pos;
+		while (this.pos < this.src.length) {
+			const code = this.src.charCodeAt(this.pos);
+			if (
+				(code >= 97 && code <= 122) ||
+				(code >= 65 && code <= 90) ||
+				(code >= 48 && code <= 57) ||
+				code === 95
+			) {
+				this.pos++;
+			} else {
+				break;
+			}
+		}
+		this.col += this.pos - start;
+		return this.src.slice(start, this.pos);
 	}
 
 	// ── Semicolon insertion ──────────────────────────────────────

package/src/lower/boxing.js

@@ -6,13 +6,7 @@ import { forEachChild } from "./walk.js";
 export function isReferenceType(t) {
 	if (!t) return false;
 	const base = t.kind === "named" ? t.underlying : t;
-	return (
-		base?.kind === "struct" ||
-		base?.kind === "slice" ||
-		base?.kind === "map" ||
-		base?.kind === "func" ||
-		base?.kind === "interface"
-	);
+	return base?.kind === "struct" || base?.kind === "func";
 }
 
 // Scan AST node for _addressTaken idents on scalars and populate a Set of boxed variable names.

package/src/lower/captures.js

@@ -2,7 +2,7 @@
 // Identifies free variables captured by closures and determines which ones
 // are mutated and thus require heap-allocated environment cells for WASM closures.
 
-import { collectMutatedVars, nodeMutatesVar } from "./ownership.js";
+import { collectMutatedVars } from "./ownership.js";
 import { forEachChild } from "./walk.js";
 
 /**
@@ -151,11 +151,7 @@ export function analyzeCaptures(fnDecl) {
 			result.capturesByClosure.set(node, captured);
 
 			for (const varName of captured) {
-				if (
-					mutatedVars.has(varName) ||
-					nodeMutatesVar(fnDecl.body, varName) ||
-					nodeMutatesVar(node.body, varName)
-				) {
+				if (mutatedVars.has(varName)) {
 					result.mutatedCaptures.add(varName);
 				}
 			}

package/src/lower/embedding.js

@@ -9,7 +9,8 @@ export function computeEmbeddedStubs(name, methodDecls, checker) {
 	const declared = new Set(methodDecls.map((m) => m.name));
 	const stubs = [];
 
-	for (const embed of resolvedType._embeds) {
+	for (const rawEmbed of resolvedType._embeds) {
+		const embed = rawEmbed.kind === "pointer" ? rawEmbed.base : rawEmbed;
 		const embedName = embed.kind === "named" ? embed.name : null;
 		if (!embedName) continue;
 		const embedBase = embed.kind === "named" ? embed.underlying : embed;