gofront 1.6.0 → 1.6.1

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

@@ -10,8 +10,7 @@ export function isReferenceType(t) {
 		base?.kind === "struct" ||
 		base?.kind === "slice" ||
 		base?.kind === "map" ||
-		base?.kind === "func" ||
-		base?.kind === "interface"
+		base?.kind === "func"
 	);
 }
 

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/ownership.js

@@ -89,19 +89,42 @@ export function collectMutatedVars(
 
 export function fnMutates(body, name, addrOnly = false, cache = null) {
 	if (!body) return true;
-	const key = `${addrOnly ? "&" : ""}${name}`;
 	if (cache) {
-		if (!cache.has(key)) {
-			cache.set(key, nodeMutatesVar(body, name, addrOnly));
+		const setKey = addrOnly ? "&*" : "*";
+		let set = cache.get(setKey);
+		if (!set) {
+			set = collectMutatedVars(body, new Set(), addrOnly);
+			cache.set(setKey, set);
 		}
-		return cache.get(key);
+		return set.has(name);
 	}
 	return nodeMutatesVar(body, name, addrOnly);
 }
 
+function collectClosureMutatedVars(node, mutated = new Set()) {
+	if (!node || typeof node !== "object") return mutated;
+	if (Array.isArray(node)) {
+		for (const item of node) collectClosureMutatedVars(item, mutated);
+		return mutated;
+	}
+	if (node.kind === "FuncLit") {
+		collectMutatedVars(node.body, mutated, false);
+		return mutated;
+	}
+	forEachChild(node, (child) => collectClosureMutatedVars(child, mutated));
+	return mutated;
+}
+
 export function closureMutates(body, name, cache = null) {
-	const key = `λ${name}`;
-	if (cache?.has(key)) return cache.get(key);
+	if (!body) return false;
+	if (cache) {
+		let set = cache.get("λ*");
+		if (!set) {
+			set = collectClosureMutatedVars(body, new Set());
+			cache.set("λ*", set);
+		}
+		return set.has(name);
+	}
 
 	const walk = (node) => {
 		if (!node || typeof node !== "object") return false;
@@ -109,9 +132,7 @@ export function closureMutates(body, name, cache = null) {
 		if (node.kind === "FuncLit") return nodeMutatesVar(node.body, name);
 		return someChild(node, walk);
 	};
-	const res = walk(body);
-	if (cache) cache.set(key, res);
-	return res;
+	return walk(body);
 }
 
 export class OwnershipContext {

package/src/minifier.js

@@ -121,7 +121,7 @@ const REGEX_CONTEXT_VALUES = new Set([
 const DIVISION_AFTER_OPS = new Set([")", "]", "++", "--"]);
 
 function _isRegexContext(tokens) {
-	const prev = lastNonWhitespaceToken(tokens);
+	const prev = findPrevNonWs(tokens);
 	if (!prev) return true;
 	if (prev.type === "op") return !DIVISION_AFTER_OPS.has(prev.value);
 	return REGEX_CONTEXT_VALUES.has(prev.value);
@@ -323,14 +323,6 @@ function tokenize(code) {
 	return tokens;
 }
 
-function lastNonWhitespaceToken(tokens) {
-	for (let i = tokens.length - 1; i >= 0; i--) {
-		if (tokens[i].type !== "ws" && tokens[i].type !== "comment")
-			return tokens[i];
-	}
-	return null;
-}
-
 // ── Stage 1 & 2: Compress ────────────────────────────────────
 
 function isIdentLike(type) {
@@ -348,15 +340,6 @@ const SPACE_AFTER_KW_RIGHT_TYPES = new Set([
 ]);
 // Operator values that do NOT need a space after a keyword
 const NO_SPACE_AFTER_KW_OPS = new Set(["(", "[", "!", "-", "+"]);
-// Adjacent op pairs that would accidentally merge into a different operator
-const _INCREMENT_MERGE_PAIRS = new Set([
-	"+|+",
-	"-|-",
-	"+|++",
-	"-|--",
-	"++|+",
-	"--|−-",
-]);
 
 function _wouldMergeUnaryOps(left, right) {
 	return (
@@ -436,11 +419,7 @@ function compressTokens(tokens) {
 	return out;
 }
 
-function compress(code) {
-	return compressTokens(tokenize(code));
-}
-
-function findPrevNonWs(tokens, index) {
+function findPrevNonWs(tokens, index = tokens.length) {
 	for (let i = index - 1; i >= 0; i--) {
 		if (tokens[i].type !== "ws" && tokens[i].type !== "comment")
 			return tokens[i];
@@ -477,7 +456,7 @@ function _matchingParen(tokens, openIdx) {
 // A `(` opens a parameter list only when its `)` is followed by a body `{` or `=>`;
 // otherwise `name(...)` is a call and its arguments may be free globals.
 function _collectParamDecls(tokens, i, declaredLocals) {
-	const prev = findPrevNonWsToken(tokens, i);
+	const prev = findPrevNonWs(tokens, i);
 	if (
 		!prev ||
 		(prev.value !== "function" && prev.type !== "ident" && prev.value !== ")")
@@ -583,22 +562,7 @@ function _filterRenameCandidates(declaredLocals) {
 	}
 }
 
-function _applyRenaming(tokens, renameMap) {
-	let out = "";
-	for (let i = 0; i < tokens.length; i++) {
-		const tok = tokens[i];
-		if (tok.type === "ident" && renameMap.has(tok.value)) {
-			const prev = findPrevNonWsToken(tokens, i);
-			out += prev && prev.value === "." ? tok.value : renameMap.get(tok.value);
-		} else {
-			out += tok.value;
-		}
-	}
-	return out;
-}
-
-function mangle(code) {
-	const tokens = tokenize(code);
+function mangleTokens(tokens) {
 	const { declaredLocals } = _collectLocalDecls(tokens);
 	_filterRenameCandidates(declaredLocals);
 
@@ -612,7 +576,15 @@ function mangle(code) {
 	const nameGen = shortNameGeneratorFn(occupied);
 	const renameMap = new Map();
 	for (const name of declaredLocals) renameMap.set(name, nameGen());
-	return _applyRenaming(tokens, renameMap);
+	return tokens.map((tok, i) => {
+		if (tok.type === "ident" && renameMap.has(tok.value)) {
+			const prev = findPrevNonWs(tokens, i);
+			if (prev?.value !== ".") {
+				return { type: "ident", value: renameMap.get(tok.value) };
+			}
+		}
+		return tok;
+	});
 }
 
 function nextNonWs(tokens, index) {
@@ -624,14 +596,6 @@ function nextNonWs(tokens, index) {
 	return null;
 }
 
-function findPrevNonWsToken(tokens, index) {
-	for (let i = index - 1; i >= 0; i--) {
-		if (tokens[i].type !== "ws" && tokens[i].type !== "comment")
-			return tokens[i];
-	}
-	return null;
-}
-
 function collectDestructured(tokens, startIdx, locals) {
 	const open = tokens[startIdx].value;
 	const close = open === "[" ? "]" : "}";
@@ -647,7 +611,7 @@ function collectDestructured(tokens, startIdx, locals) {
 }
 
 function _isParamStart(tokens, i) {
-	const prev = findPrevNonWsToken(tokens, i);
+	const prev = findPrevNonWs(tokens, i);
 	return (
 		!prev ||
 		prev.value === "(" ||
@@ -839,28 +803,16 @@ function foldTokens(tokens) {
 	return current;
 }
 
-function foldLiterals(code) {
-	const tokens = tokenize(code);
-	return compressTokens(foldTokens(tokens));
-}
-
 // ── Public API ───────────────────────────────────────────────
 
 export function minify(code, options = {}) {
 	const { mangle: doMangle = false } = options;
-
-	// Stage 1 + 2: compress (strips comments, whitespace, compresses tokens)
-	let result = compress(code);
-
-	// Stage 4: literal folding
-	result = foldLiterals(result);
-
-	// Stage 3: mangling (optional)
+	let tokens = tokenize(code).filter(
+		(t) => t.type !== "ws" && t.type !== "comment",
+	);
+	tokens = foldTokens(tokens);
 	if (doMangle) {
-		result = mangle(result);
-		// Re-compress after mangling to clean up any leftover whitespace
-		result = compress(result);
+		tokens = mangleTokens(tokens);
 	}
-
-	return result;
+	return compressTokens(tokens);
 }

package/src/parser/declarations.js

@@ -261,8 +261,7 @@ export const declarationParseMethods = {
 	},
 
 	parseVarSpec() {
-		const names = [this.expect(T.IDENT).value];
-		while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
+		const names = this.parseIdentList();
 		let type = null;
 		let value = null;
 		if (
@@ -284,8 +283,7 @@ export const declarationParseMethods = {
 			let prevRawExprs = null; // raw AST (with iota Idents) from the previous spec
 			let prevType = null;
 			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
-				const names = [this.expect(T.IDENT).value];
-				while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
+				const names = this.parseIdentList();
 				let type = null;
 				let rawExprs; // before iota substitution
 				if (this.check(T.ASSIGN)) {
@@ -315,8 +313,7 @@ export const declarationParseMethods = {
 			}
 			this.expect(T.RPAREN);
 		} else {
-			const names = [this.expect(T.IDENT).value];
-			while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
+			const names = this.parseIdentList();
 			let type = null;
 			if (!this.check(T.ASSIGN)) type = this.parseType();
 			this.expect(T.ASSIGN);

package/src/parser/expressions.js

@@ -25,6 +25,8 @@ const PREC = {
 	[T.AND_NOT]: 5,
 };
 
+const UNARY_OPS = new Set([T.NOT, T.MINUS, T.PLUS, T.CARET, T.AMP, T.STAR]);
+
 const TYPE_KEYWORDS = new Set([
 	"int",
 	"int8",
@@ -128,14 +130,7 @@ export const expressionParserMethods = {
 
 	parseUnary(noCompLit = false) {
 		const t = this.peek();
-		if (
-			t.type === T.NOT ||
-			t.type === T.MINUS ||
-			t.type === T.PLUS ||
-			t.type === T.CARET ||
-			t.type === T.AMP ||
-			t.type === T.STAR
-		) {
+		if (UNARY_OPS.has(t.type)) {
 			const op = this.advance().value;
 			return { kind: "UnaryExpr", op, operand: this.parseUnary(noCompLit) };
 		}

package/src/parser/index.js

@@ -73,9 +73,18 @@ export class Parser {
 		return this.peek2().type === type;
 	}
 
-	match(...types) {
-		for (const type of types) {
-			if (this.check(type)) {
+	match(t1, t2, t3, ...rest) {
+		const cur = this.peek().type;
+		if (
+			cur === t1 ||
+			(t2 !== undefined && cur === t2) ||
+			(t3 !== undefined && cur === t3)
+		) {
+			this.advance();
+			return true;
+		}
+		for (let i = 0; i < rest.length; i++) {
+			if (cur === rest[i]) {
 				this.advance();
 				return true;
 			}
@@ -83,6 +92,12 @@ export class Parser {
 		return false;
 	}
 
+	parseIdentList() {
+		const names = [this.expect(T.IDENT).value];
+		while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
+		return names;
+	}
+
 	expect(type) {
 		if (!this.check(type))
 			throw new ParseError(`expected '${type}'`, this.peek());

package/src/parser/statements.js

@@ -15,6 +15,20 @@ const PARSE_STMT_DELEGATE = {
 	[T.LBRACE]: "parseBlock",
 };
 
+const ASSIGN_OPS = new Set([
+	T.ASSIGN,
+	T.PLUS_ASSIGN,
+	T.MINUS_ASSIGN,
+	T.STAR_ASSIGN,
+	T.SLASH_ASSIGN,
+	T.PERCENT_ASSIGN,
+	T.AMP_ASSIGN,
+	T.PIPE_ASSIGN,
+	T.CARET_ASSIGN,
+	T.LSHIFT_ASSIGN,
+	T.RSHIFT_ASSIGN,
+]);
+
 export const statementParserMethods = {
 	parseBlock() {
 		this.expect(T.LBRACE);
@@ -206,22 +220,13 @@ export const statementParserMethods = {
 		this.expect(T.LBRACE);
 		const cases = [];
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
-			if (this.check(T.CASE)) {
-				this.advance();
-				const list = this.parseExprList();
-				this.expect(T.COLON);
-				cases.push({ kind: "CaseClause", list, stmts: this._parseCaseBody() });
-			} else if (this.check(T.DEFAULT)) {
-				this.advance();
-				this.expect(T.COLON);
-				cases.push({
-					kind: "CaseClause",
-					list: null,
-					stmts: this._parseCaseBody(),
-				});
-			} else {
+			const isCase = this.match(T.CASE);
+			if (!isCase && !this.match(T.DEFAULT)) {
 				this.err("Expected case or default");
 			}
+			const list = isCase ? this.parseExprList() : null;
+			this.expect(T.COLON);
+			cases.push({ kind: "CaseClause", list, stmts: this._parseCaseBody() });
 		}
 		this.expect(T.RBRACE);
 		return { kind: "SwitchStmt", init, tag, cases };
@@ -244,18 +249,13 @@ export const statementParserMethods = {
 		this.expect(T.LBRACE);
 		const cases = [];
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
-			if (this.check(T.CASE)) {
-				this.advance();
-				const types = this._parseTypeSwitchTypeList();
-				this.expect(T.COLON);
-				cases.push({ types, stmts: this._parseCaseBody() });
-			} else if (this.check(T.DEFAULT)) {
-				this.advance();
-				this.expect(T.COLON);
-				cases.push({ types: null, stmts: this._parseCaseBody() });
-			} else {
+			const isCase = this.match(T.CASE);
+			if (!isCase && !this.match(T.DEFAULT)) {
 				this.err("Expected case or default");
 			}
+			const types = isCase ? this._parseTypeSwitchTypeList() : null;
+			this.expect(T.COLON);
+			cases.push({ types, stmts: this._parseCaseBody() });
 		}
 		this.expect(T.RBRACE);
 		return { kind: "TypeSwitchStmt", assign, expr, cases };
@@ -305,20 +305,7 @@ export const statementParserMethods = {
 		}
 
 		// x = expr  or  x += expr  etc.
-		const assignOps = [
-			T.ASSIGN,
-			T.PLUS_ASSIGN,
-			T.MINUS_ASSIGN,
-			T.STAR_ASSIGN,
-			T.SLASH_ASSIGN,
-			T.PERCENT_ASSIGN,
-			T.AMP_ASSIGN,
-			T.PIPE_ASSIGN,
-			T.CARET_ASSIGN,
-			T.LSHIFT_ASSIGN,
-			T.RSHIFT_ASSIGN,
-		];
-		if (assignOps.includes(t.type)) {
+		if (ASSIGN_OPS.has(t.type)) {
 			const op = this.advance().value;
 			const rhs = this.parseExprList();
 			return { kind: "AssignStmt", lhs: [first], op, rhs };

package/src/parser/types.js

@@ -175,8 +175,7 @@ export const typeParserMethods = {
 		this.expect(T.LBRACE);
 		const fields = [];
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
-			const names = [this.expect(T.IDENT).value];
-			while (this.match(T.COMMA)) names.push(this.expect(T.IDENT).value);
+			const names = this.parseIdentList();
 			// Check if this is an embedded field (just a type name)
 			// e.g., type T struct { Base }
 			if (this.check(T.SEMICOLON) || this.check(T.RBRACE)) {

package/src/resolver.js

@@ -25,32 +25,7 @@ function findNodeModules(startDir) {
 	}
 }
 
-// Built-in stdlib package paths that are always available as globals — no resolution needed.
-const BUILTIN_PACKAGES = new Set([
-	"fmt",
-	"strings",
-	"bytes",
-	"strconv",
-	"sort",
-	"math",
-	"math/bits",
-	"math/rand",
-	"errors",
-	"time",
-	"unicode",
-	"unicode/utf8",
-	"os",
-	"slices",
-	"html",
-	"io",
-	"gom",
-	"maps",
-	"regexp",
-	"path",
-	"path/filepath",
-	"testing",
-	"gofront/shared",
-]);
+import { STDLIB_PACKAGES } from "./typechecker/types.js";
 
 // Returns true for local relative paths (start with ./ or ../)
 export function isLocalPath(importPath) {
@@ -58,7 +33,7 @@ export function isLocalPath(importPath) {
 }
 
 export function isBuiltinPackage(importPath) {
-	return BUILTIN_PACKAGES.has(importPath);
+	return STDLIB_PACKAGES.has(importPath);
 }
 
 // Resolve a local relative import path to an absolute directory of .go files.