gofront 1.6.0 → 1.7.0

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/struct-tag.js

@@ -0,0 +1,144 @@
+// src/parser/struct-tag.js
+// Parse Go struct field tags matching Go's reflect.StructTag specification.
+
+function unquoteTagValue(s) {
+	if (s.length < 2 || s[0] !== '"' || s[s.length - 1] !== '"') return s;
+	const inner = s.slice(1, -1);
+	let res = "";
+	for (let i = 0; i < inner.length; i++) {
+		if (inner[i] === "\\" && i + 1 < inner.length) {
+			i++;
+			const esc = inner[i];
+			switch (esc) {
+				case "n":
+					res += "\n";
+					break;
+				case "t":
+					res += "\t";
+					break;
+				case "r":
+					res += "\r";
+					break;
+				case '"':
+					res += '"';
+					break;
+				case "\\":
+					res += "\\";
+					break;
+				case "a":
+					res += "\x07";
+					break;
+				case "b":
+					res += "\b";
+					break;
+				case "f":
+					res += "\f";
+					break;
+				case "v":
+					res += "\v";
+					break;
+				case "0":
+					res += "\0";
+					break;
+				default:
+					res += `\\${esc}`;
+					break;
+			}
+		} else {
+			res += inner[i];
+		}
+	}
+	return res;
+}
+
+/**
+ * Parses a raw struct tag string into a Map of key -> unquoted string value,
+ * adhering to Go reflect.StructTag convention.
+ *
+ * @param {string | null | undefined} tag
+ * @returns {Map<string, string>}
+ */
+export function parseStructTag(tag) {
+	const map = new Map();
+	if (!tag || typeof tag !== "string") return map;
+
+	let str = tag;
+	while (str.length > 0) {
+		// Skip leading spaces
+		let i = 0;
+		while (i < str.length && str.charCodeAt(i) === 32) i++;
+		str = str.slice(i);
+		if (str.length === 0) break;
+
+		// Scan to colon: key must not contain space, quote, colon, or control characters
+		i = 0;
+		while (
+			i < str.length &&
+			str.charCodeAt(i) > 32 &&
+			str[i] !== ":" &&
+			str[i] !== '"' &&
+			str.charCodeAt(i) !== 127
+		) {
+			i++;
+		}
+		if (
+			i === 0 ||
+			i + 1 >= str.length ||
+			str[i] !== ":" ||
+			str[i + 1] !== '"'
+		) {
+			break;
+		}
+		const key = str.slice(0, i);
+		str = str.slice(i + 1); // skip colon, now points to opening '"'
+
+		// Scan quoted string to find closing '"'
+		i = 1;
+		while (i < str.length && str[i] !== '"') {
+			if (str[i] === "\\") i++; // skip escaped char
+			i++;
+		}
+		if (i >= str.length) break;
+
+		const qval = str.slice(0, i + 1);
+		str = str.slice(i + 1);
+
+		if (!map.has(key)) {
+			map.set(key, unquoteTagValue(qval));
+		}
+	}
+	return map;
+}
+
+/**
+ * Parses the "json" key from a struct tag string or parsed Map according to encoding/json rules.
+ *
+ * @param {string | Map<string, string> | null | undefined} tag
+ * @returns {{ name: string | null, omitempty: boolean, ignored: boolean, options: string[] }}
+ */
+export function parseJsonTag(tag) {
+	if (!tag) {
+		return { name: null, omitempty: false, ignored: false, options: [] };
+	}
+	const map = typeof tag === "string" ? parseStructTag(tag) : tag;
+	if (!map.has("json")) {
+		return { name: null, omitempty: false, ignored: false, options: [] };
+	}
+	const raw = map.get("json");
+	const parts = raw.split(",");
+	const rawName = parts[0];
+	const options = parts.slice(1);
+	const omitempty = options.includes("omitempty");
+
+	if (rawName === "-" && parts.length === 1) {
+		return { name: "-", omitempty: false, ignored: true, options };
+	}
+
+	const name = rawName === "" ? null : rawName;
+	return {
+		name,
+		omitempty,
+		ignored: false,
+		options,
+	};
+}

package/src/parser/types.js

@@ -175,24 +175,80 @@ 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);
-			// 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)) {
-				const typeName = names[0]; // assuming no comma list for embedded
+			// Embedded pointer field: *Base or *pkg.Base
+			if (this.check(T.STAR)) {
+				this.advance();
+				let typeName = this.expect(T.IDENT).value;
+				if (this.check(T.DOT)) {
+					this.advance();
+					typeName += `.${this.expect(T.IDENT).value}`;
+				}
+				const type = {
+					kind: "PointerType",
+					base: { kind: "TypeName", name: typeName },
+				};
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
+				fields.push({
+					names: [],
+					type,
+					embedded: true,
+					tag,
+				});
+				this.semi();
+				continue;
+			}
+
+			const names = this.parseIdentList();
+			// Check if this is a qualified embedded field: pkg.Base
+			if (names.length === 1 && this.check(T.DOT)) {
+				this.advance();
+				const typeName = `${names[0]}.${this.expect(T.IDENT).value}`;
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
 				fields.push({
 					names: [],
 					type: { kind: "TypeName", name: typeName },
 					embedded: true,
+					tag,
 				});
 				this.semi();
 				continue;
 			}
+
+			// Embedded field (just a type name, e.g. Base), optionally tagged
+			if (
+				names.length === 1 &&
+				(this.check(T.SEMICOLON) ||
+					this.check(T.RBRACE) ||
+					this.check(T.STRING))
+			) {
+				const typeName = names[0];
+				let tag = null;
+				if (this.check(T.STRING)) {
+					tag = this.advance().value;
+				}
+				fields.push({
+					names: [],
+					type: { kind: "TypeName", name: typeName },
+					embedded: true,
+					tag,
+				});
+				this.semi();
+				continue;
+			}
+
 			const type = this.parseType();
 			// Consume optional struct tag (backtick string), e.g. `json:"name"`
-			if (this.check(T.STRING)) this.advance();
-			fields.push({ names, type });
+			let tag = null;
+			if (this.check(T.STRING)) {
+				tag = this.advance().value;
+			}
+			fields.push({ names, type, tag });
 			this.semi();
 		}
 		this.expect(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.