gofront 1.4.0 → 1.5.1

package/src/lower/functions.js

@@ -0,0 +1,30 @@
+// src/lower/functions.js
+// Analyzes function signatures, named returns and defer structures.
+
+export function extractNamedReturns(decl) {
+	const named = decl?.returnType?._namedReturns;
+	if (!named || named.length === 0) return null;
+	return {
+		entries: named, // [{ name, type }]
+		names: named.map((r) => r.name).filter(Boolean),
+	};
+}
+
+export function hasDefer(body) {
+	if (!body) return false;
+	if (body._hasDefer != null) return Boolean(body._hasDefer);
+
+	const walk = (node) => {
+		if (!node || typeof node !== "object") return false;
+		if (Array.isArray(node)) return node.some(walk);
+		if (node.kind === "DeferStmt") return true;
+		if (node.kind === "FuncLit") return false; // separate function boundary
+		for (const key of Object.keys(node)) {
+			if (key.startsWith("_")) continue;
+			if (walk(node[key])) return true;
+		}
+		return false;
+	};
+
+	return walk(body);
+}

package/src/lower/globals.js

@@ -0,0 +1,324 @@
+// src/lower/globals.js
+// Identifies package-level globals that are never assigned outside init,
+// and computes functions that participate in the package initialization call path.
+
+import { isReferenceType } from "./boxing.js";
+
+/**
+ * Computes:
+ * - neverAssignedGlobals: Set of package variable names that are never reassigned outside init.
+ * - initPathFunctions: Set of function/method names reachable during package initialization.
+ * - cachedGlobalsByFunc: Map of AST function declarations to list of global names to cache.
+ *
+ * @param {Array<Object>} programs
+ * @param {Object} [_checker]
+ * @returns {{ neverAssignedGlobals: Set<string>, initPathFunctions: Set<string>, cachedGlobalsByFunc: Map<Object, Array<string>> }}
+ */
+export function computeGlobalAnalysis(programs, _checker = null) {
+	const progs = Array.isArray(programs) ? programs : [programs];
+	const packageGlobals = collectPackageGlobals(progs);
+	const reassigned = collectReassigned(progs, packageGlobals);
+
+	const neverAssignedGlobals = new Set();
+	for (const g of packageGlobals) {
+		if (!reassigned.has(g)) neverAssignedGlobals.add(g);
+	}
+
+	const initPathFunctions = buildInitPathFunctions(progs);
+	const cachedGlobalsByFunc = buildCachedGlobalsMap(
+		progs,
+		neverAssignedGlobals,
+		initPathFunctions,
+	);
+
+	return { neverAssignedGlobals, initPathFunctions, cachedGlobalsByFunc };
+}
+
+function collectVarNames(spec, out) {
+	const names = spec.names ?? (spec.name ? [spec.name] : []);
+	for (const n of names) {
+		const name = typeof n === "string" ? n : n?.name;
+		if (name && name !== "_") out.add(name);
+	}
+}
+
+function collectPackageGlobals(programs) {
+	const out = new Set();
+	for (const p of programs) {
+		for (const d of p?.decls ?? []) {
+			if (d.kind === "VarDecl") {
+				for (const spec of d.decls ?? d.specs ?? [d]) {
+					collectVarNames(spec, out);
+				}
+			}
+		}
+	}
+	return out;
+}
+
+function collectReassigned(programs, packageGlobals) {
+	const reassigned = new Set();
+	for (const p of programs) {
+		for (const d of p?.decls ?? []) {
+			if (d.kind === "FuncDecl" || d.kind === "MethodDecl") {
+				const isInit =
+					d.kind === "FuncDecl" &&
+					(d.name === "init" || d.name.startsWith("init$"));
+				scanReassignments(d.body, packageGlobals, reassigned, isInit);
+			}
+		}
+	}
+	return reassigned;
+}
+
+function checkAssignLhs(lhs, packageGlobals, reassigned) {
+	for (const l of lhs ?? []) {
+		if (l.kind === "Ident" && packageGlobals.has(l.name)) {
+			reassigned.add(l.name);
+		}
+	}
+}
+
+function checkIncDec(stmt, packageGlobals, reassigned) {
+	if (stmt.expr?.kind === "Ident" && packageGlobals.has(stmt.expr.name)) {
+		reassigned.add(stmt.expr.name);
+	}
+}
+
+function checkAddressTaken(node, packageGlobals, reassigned) {
+	if (
+		node.kind === "Ident" &&
+		node._addressTaken &&
+		packageGlobals.has(node.name)
+	) {
+		if (!isReferenceType(node._type)) {
+			reassigned.add(node.name);
+		}
+	}
+}
+
+function scanReassignments(node, packageGlobals, reassigned, insideInit) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) {
+			scanReassignments(child, packageGlobals, reassigned, insideInit);
+		}
+		return;
+	}
+	if (node.kind === "FuncLit") {
+		scanReassignments(node.body, packageGlobals, reassigned, false);
+		return;
+	}
+	if (!insideInit) {
+		if (node.kind === "AssignStmt" || node.kind === "CompoundAssignStmt") {
+			checkAssignLhs(node.lhs, packageGlobals, reassigned);
+		} else if (node.kind === "IncDecStmt") {
+			checkIncDec(node, packageGlobals, reassigned);
+		}
+	}
+	checkAddressTaken(node, packageGlobals, reassigned);
+	for (const k of Object.keys(node)) {
+		if (!k.startsWith("_")) {
+			scanReassignments(node[k], packageGlobals, reassigned, insideInit);
+		}
+	}
+}
+
+function addCallTarget(call, called) {
+	if (call.func?.kind === "Ident") {
+		called.add(call.func.name);
+		return;
+	}
+	if (call.func?.kind === "SelectorExpr") {
+		const sel = call.func.sel ?? call.func.field;
+		if (sel) called.add(sel);
+		const typeName =
+			call.func.expr?._type?.name ?? call.func.expr?._type?.base?.name;
+		if (typeName && sel) called.add(`${typeName}.${sel}`);
+	}
+}
+
+function findCalledFunctions(node, called = new Set()) {
+	if (!node || typeof node !== "object") return called;
+	if (Array.isArray(node)) {
+		for (const child of node) findCalledFunctions(child, called);
+		return called;
+	}
+	if (node.kind === "CallExpr") addCallTarget(node, called);
+	for (const k of Object.keys(node)) {
+		if (!k.startsWith("_")) findCalledFunctions(node[k], called);
+	}
+	return called;
+}
+
+function addCallees(callGraph, caller, callees) {
+	let set = callGraph.get(caller);
+	if (!set) {
+		set = new Set();
+		callGraph.set(caller, set);
+	}
+	for (const c of callees) set.add(c);
+}
+
+function buildInitSeeds(programs) {
+	const seeds = new Set(["init", "__init_globals"]);
+	for (const p of programs) {
+		for (const d of p?.decls ?? []) {
+			if (
+				d.kind === "FuncDecl" &&
+				(d.name === "init" || d.name.startsWith("init$"))
+			) {
+				seeds.add(d.name);
+			}
+			if (d.kind === "VarDecl") {
+				for (const spec of d.decls ?? d.specs ?? [d]) {
+					const values = spec.value ?? (spec.init ? [spec.init] : []);
+					for (const val of values) findCalledFunctions(val, seeds);
+				}
+			}
+		}
+	}
+	return seeds;
+}
+
+function buildCallGraph(programs) {
+	const callGraph = new Map();
+	for (const p of programs) {
+		for (const d of p?.decls ?? []) {
+			if ((d.kind === "FuncDecl" || d.kind === "MethodDecl") && d.body) {
+				const callees = findCalledFunctions(d.body);
+				addCallees(callGraph, d.name, callees);
+				if (d.kind === "MethodDecl" && d.recvType?.name) {
+					addCallees(callGraph, `${d.recvType.name}.${d.name}`, callees);
+				}
+			}
+		}
+	}
+	return callGraph;
+}
+
+function buildInitPathFunctions(programs) {
+	const seeds = buildInitSeeds(programs);
+	const callGraph = buildCallGraph(programs);
+	const initPath = new Set(seeds);
+	const worklist = Array.from(seeds);
+	while (worklist.length > 0) {
+		const caller = worklist.pop();
+		const callees = callGraph.get(caller);
+		if (callees) {
+			for (const callee of callees) {
+				if (!initPath.has(callee)) {
+					initPath.add(callee);
+					worklist.push(callee);
+				}
+			}
+		}
+	}
+	return initPath;
+}
+
+// Idents read anywhere in the function, nested closures included: the emitter
+// narrows the list per emitted body (root vs. each lifted closure).
+function scanReadIdents(node, readSet) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const c of node) scanReadIdents(c, readSet);
+		return;
+	}
+	if (node.kind === "SelectorExpr") {
+		scanReadIdents(node.expr, readSet);
+		return;
+	}
+	if (node.kind === "DefineStmt") {
+		scanReadIdents(node.rhs, readSet);
+		return;
+	}
+	if (node.kind === "AssignStmt" || node.kind === "CompoundAssignStmt") {
+		for (const l of node.lhs ?? []) {
+			if (l.kind !== "Ident") scanReadIdents(l, readSet);
+		}
+		scanReadIdents(node.rhs, readSet);
+		return;
+	}
+	if (node.kind === "Ident" && typeof node.name === "string") {
+		readSet.add(node.name);
+		return;
+	}
+	for (const k of Object.keys(node)) {
+		if (!k.startsWith("_")) scanReadIdents(node[k], readSet);
+	}
+}
+
+function isLocallyDeclared(node, name) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some((c) => isLocallyDeclared(c, name));
+	if (node.kind === "FuncLit") return false;
+	if (node.kind === "DefineStmt") {
+		return Boolean(
+			node.lhs?.some((l) => l.kind === "Ident" && l.name === name),
+		);
+	}
+	if (node.kind === "VarDecl") {
+		for (const s of node.decls ?? node.specs ?? []) {
+			const names = s.names ?? (s.name ? [s.name] : []);
+			if (names.some((n) => (typeof n === "string" ? n : n.name) === name))
+				return true;
+		}
+	}
+	for (const k of Object.keys(node)) {
+		if (!k.startsWith("_") && isLocallyDeclared(node[k], name)) return true;
+	}
+	return false;
+}
+
+function getGlobalsToCache(fn, neverAssignedGlobals, initPathFunctions) {
+	if (!fn.body || neverAssignedGlobals.size === 0) return [];
+	if (fn._isGlobalInit || fn.name === "init" || fn.name.startsWith("init$"))
+		return [];
+	if (initPathFunctions.has(fn.name)) return [];
+	if (fn._methodName && initPathFunctions.has(fn._methodName)) return [];
+	if (
+		fn.recvType?.name &&
+		initPathFunctions.has(`${fn.recvType.name}.${fn.name}`)
+	)
+		return [];
+
+	const paramNames = new Set((fn.params ?? []).map((p) => p.name));
+	if (fn.recvName) paramNames.add(fn.recvName);
+
+	const reads = new Set();
+	scanReadIdents(fn.body, reads);
+
+	const result = [];
+	for (const name of Array.from(neverAssignedGlobals).sort()) {
+		if (
+			reads.has(name) &&
+			!paramNames.has(name) &&
+			!isLocallyDeclared(fn.body, name)
+		) {
+			result.push(name);
+		}
+	}
+	return result;
+}
+
+function buildCachedGlobalsMap(
+	programs,
+	neverAssignedGlobals,
+	initPathFunctions,
+) {
+	const map = new Map();
+	for (const p of programs) {
+		for (const d of p?.decls ?? []) {
+			if ((d.kind === "FuncDecl" || d.kind === "MethodDecl") && d.body) {
+				const globals = getGlobalsToCache(
+					d,
+					neverAssignedGlobals,
+					initPathFunctions,
+				);
+				if (globals.length > 0) map.set(d, globals);
+			}
+		}
+	}
+	return map;
+}

package/src/lower/index.js

@@ -0,0 +1,115 @@
+// src/lower/index.js
+// Lowering step: analyzes AST and types to populate side-tables for backends (JS and WASM).
+
+export * from "./boxing.js";
+export * from "./captures.js";
+export * from "./embedding.js";
+export * from "./escape.js";
+export * from "./functions.js";
+export * from "./globals.js";
+export * from "./ownership.js";
+export * from "./range.js";
+
+import { scanAddressTaken } from "./boxing.js";
+import { analyzeCaptures } from "./captures.js";
+import { computeEmbeddedStubs } from "./embedding.js";
+import { paramEscapes } from "./escape.js";
+import { extractNamedReturns, hasDefer } from "./functions.js";
+import { computeGlobalAnalysis } from "./globals.js";
+import { OwnershipContext } from "./ownership.js";
+
+export class LowerResult {
+	constructor() {
+		// Map<ASTNode (FuncDecl, MethodDecl, FuncLit), Set<string>>
+		this.boxedVars = new Map();
+		// Map<ASTNode, OwnershipContext>
+		this.ownership = new Map();
+		// Map<ASTNode, Object>
+		this.functions = new Map();
+		// Map<string, Array<{ methodName: string, embedName: string }>>
+		this.embeddedStubs = new Map();
+		// Map<ASTNode, CaptureAnalysis>
+		this.captures = new Map();
+		// Map<ASTNode, Set<string>>
+		this.escapes = new Map();
+		// Set<string>
+		this.neverAssignedGlobals = new Set();
+		// Set<string>
+		this.initPathFunctions = new Set();
+		// Map<ASTNode, Array<string>>
+		this.cachedGlobalsByFunc = new Map();
+	}
+}
+
+/**
+ * Runs lowering analyses across an AST or collection of programs, returning side-tables.
+ * @param {Object} programOrPrograms
+ * @param {Object} checker
+ * @returns {LowerResult}
+ */
+export function lower(programOrPrograms, checker = null) {
+	const res = new LowerResult();
+	const programs = Array.isArray(programOrPrograms)
+		? programOrPrograms
+		: [programOrPrograms];
+
+	// 1. Aggregate methods across all files in the package
+	const methodMap = new Map();
+	for (const program of programs) {
+		for (const d of program?.decls ?? []) {
+			if (d.kind === "MethodDecl" && d.recvType?.name) {
+				const recvTypeName = d.recvType.name;
+				if (!methodMap.has(recvTypeName)) methodMap.set(recvTypeName, []);
+				methodMap.get(recvTypeName).push(d);
+			}
+		}
+	}
+
+	// 2. Perform lowering passes
+	for (const program of programs) {
+		if (!program?.decls) continue;
+
+		for (const d of program.decls) {
+			if (d.kind === "FuncDecl" || d.kind === "MethodDecl") {
+				if (d.body) {
+					const boxed = scanAddressTaken(d.body, new Set());
+					res.boxedVars.set(d, boxed);
+					res.ownership.set(d, new OwnershipContext(d.body));
+					res.functions.set(d, {
+						hasDefer: hasDefer(d.body),
+						namedReturns: extractNamedReturns(d),
+					});
+					res.captures.set(d, analyzeCaptures(d));
+
+					const escapingParams = new Set();
+					for (const p of d.params ?? []) {
+						if (p.name && p.name !== "_" && paramEscapes(d.body, p.name)) {
+							escapingParams.add(p.name);
+						}
+					}
+					res.escapes.set(d, escapingParams);
+				}
+			}
+		}
+
+		// Compute embedded stubs for structs
+		if (checker) {
+			for (const d of program.decls) {
+				if (d.kind === "TypeDecl" && d.type?.kind === "StructType") {
+					const methods = methodMap.get(d.name) ?? [];
+					const stubs = computeEmbeddedStubs(d.name, methods, checker);
+					res.embeddedStubs.set(d.name, stubs);
+				}
+			}
+		}
+	}
+
+	// 3. Compute package-level global analysis
+	const { neverAssignedGlobals, initPathFunctions, cachedGlobalsByFunc } =
+		computeGlobalAnalysis(programs, checker);
+	res.neverAssignedGlobals = neverAssignedGlobals;
+	res.initPathFunctions = initPathFunctions;
+	res.cachedGlobalsByFunc = cachedGlobalsByFunc;
+
+	return res;
+}

package/src/lower/ownership.js

@@ -0,0 +1,142 @@
+// src/lower/ownership.js
+// Tracks variable ownership, mutation and clone elision for Go value semantics.
+
+export function rootIdentName(e) {
+	while (e) {
+		if (e.kind === "Ident") return e.name;
+		if (e.kind === "SelectorExpr" || e.kind === "IndexExpr") e = e.expr;
+		else if (e.kind === "UnaryExpr" && e.op === "*") e = e.operand;
+		else return null;
+	}
+	return null;
+}
+
+// True when `node` itself (not its children) writes to variable `name`.
+export function nodeWritesVar(node, name) {
+	const root = (e) => rootIdentName(e) === name;
+	switch (node.kind) {
+		case "AssignStmt":
+			return node.lhs.some(root);
+		case "DefineStmt":
+			return node.lhs.some((e) => e._redecl && e.name === name);
+		case "IncDecStmt":
+			return root(node.expr);
+		case "SelectorExpr":
+			return Boolean(
+				node._isMethodValue && node._type?._ptrRecv && root(node.expr),
+			);
+		default:
+			return false;
+	}
+}
+
+// True when `node` may modify (or take the address of) the value held by variable `name`.
+export function nodeMutatesVar(node, name, addrOnly = false) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node))
+		return node.some((n) => nodeMutatesVar(n, name, addrOnly));
+	if (
+		node.kind === "UnaryExpr" &&
+		node.op === "&" &&
+		rootIdentName(node.operand) === name
+	)
+		return true;
+	if (!addrOnly && nodeWritesVar(node, name)) return true;
+	for (const key of Object.keys(node)) {
+		if (key.startsWith("_")) continue;
+		if (nodeMutatesVar(node[key], name, addrOnly)) return true;
+	}
+	return false;
+}
+
+// Single-pass collector of all mutated or address-taken variables in an AST node.
+export function collectMutatedVars(
+	node,
+	mutated = new Set(),
+	addrOnly = false,
+) {
+	if (!node || typeof node !== "object") return mutated;
+	if (Array.isArray(node)) {
+		for (const item of node) collectMutatedVars(item, mutated, addrOnly);
+		return mutated;
+	}
+
+	if (node.kind === "UnaryExpr" && node.op === "&") {
+		const root = rootIdentName(node.operand);
+		if (root) mutated.add(root);
+	} else if (!addrOnly) {
+		if (node.kind === "AssignStmt") {
+			for (const e of node.lhs) {
+				const root = rootIdentName(e);
+				if (root) mutated.add(root);
+			}
+		} else if (node.kind === "DefineStmt") {
+			for (const e of node.lhs) {
+				if (e._redecl && e.name) mutated.add(e.name);
+			}
+		} else if (node.kind === "IncDecStmt") {
+			const root = rootIdentName(node.expr);
+			if (root) mutated.add(root);
+		} else if (node.kind === "SelectorExpr") {
+			if (node._isMethodValue && node._type?._ptrRecv) {
+				const root = rootIdentName(node.expr);
+				if (root) mutated.add(root);
+			}
+		}
+	}
+
+	for (const key of Object.keys(node)) {
+		if (key.startsWith("_")) continue;
+		collectMutatedVars(node[key], mutated, addrOnly);
+	}
+	return mutated;
+}
+
+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));
+		}
+		return cache.get(key);
+	}
+	return nodeMutatesVar(body, name, addrOnly);
+}
+
+export function closureMutates(body, name, cache = null) {
+	const key = `λ${name}`;
+	if (cache?.has(key)) return cache.get(key);
+
+	const walk = (node) => {
+		if (!node || typeof node !== "object") return false;
+		if (Array.isArray(node)) return node.some(walk);
+		if (node.kind === "FuncLit") return nodeMutatesVar(node.body, name);
+		return Object.keys(node).some((k) => !k.startsWith("_") && walk(node[k]));
+	};
+	const res = walk(body);
+	if (cache) cache.set(key, res);
+	return res;
+}
+
+export class OwnershipContext {
+	constructor(body) {
+		this.body = body;
+		this.mut = new Map();
+		this.owned = new Set();
+		this.borrowed = new Set();
+	}
+
+	markOwnership(name, owned) {
+		if (!name || name === "_") return;
+		(owned ? this.owned : this.borrowed).add(name);
+	}
+
+	fnMutates(name, addrOnly = false) {
+		return fnMutates(this.body, name, addrOnly, this.mut);
+	}
+
+	closureMutates(name) {
+		return closureMutates(this.body, name, this.mut);
+	}
+}

package/src/lower/range.js

@@ -0,0 +1,70 @@
+// src/lower/range.js
+// Classifies for-range loop shapes and variable scoping/redelcarations.
+
+import { isNumeric } from "../typechecker/types.js";
+
+export function isRangeFor(stmt) {
+	if (!stmt?.init) return false;
+	const init = stmt.init;
+	if (init.kind !== "DefineStmt" && init.kind !== "AssignStmt") return false;
+	return init.rhs?.[0]?.kind === "RangeExpr";
+}
+
+export function isIntRangeType(iterType) {
+	return isNumeric(iterType);
+}
+
+export function isMapRangeType(iterType) {
+	return (
+		iterType?.kind === "map" ||
+		(iterType?.kind === "named" && iterType.underlying?.kind === "map")
+	);
+}
+
+export function isStringRangeType(iterType) {
+	return (
+		(iterType?.kind === "basic" && iterType.name === "string") ||
+		(iterType?.kind === "untyped" && iterType.base === "string")
+	);
+}
+
+// True when `node` contains an assignment or ++/-- targeting identifier `name`.
+export function nodeAssigns(node, name) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some((n) => nodeAssigns(n, name));
+	if (
+		(node.kind === "AssignStmt" &&
+			node.lhs.some((e) => e.kind === "Ident" && e.name === name)) ||
+		(node.kind === "IncDecStmt" &&
+			node.expr.kind === "Ident" &&
+			node.expr.name === name)
+	)
+		return true;
+	for (const key of Object.keys(node)) {
+		if (key.startsWith("_")) continue;
+		if (nodeAssigns(node[key], name)) return true;
+	}
+	return false;
+}
+
+// True when the body re-declares one of `names` at its top level (legal Go shadowing).
+export function bodyRedeclares(body, names) {
+	if (!names || names.length === 0) return false;
+	for (const s of body?.stmts ?? []) {
+		if (s.kind === "DefineStmt" && s.lhs.some((e) => names.includes(e.name)))
+			return true;
+		if (
+			(s.kind === "VarDecl" || s.kind === "ConstDecl") &&
+			s.decls?.some((d) => d.names?.some((n) => names.includes(n)))
+		)
+			return true;
+	}
+	return false;
+}
+
+// Whether `for i := range n` can be emitted as a plain `for (let i = 0; …)` without hidden registers.
+export function isSimpleIntRange(stmt, name, isAssign, boxedVars = new Set()) {
+	if (isAssign) return false;
+	if (!name || name === "_") return true;
+	return !boxedVars.has(name) && !nodeAssigns(stmt.body, name);
+}

package/src/minifier.js

@@ -219,6 +219,8 @@ function _scanNumber(code, i, len) {
 	} else {
 		j = _scanDecimalNumber(code, j, len);
 	}
+	// BigInt literal suffix (`123n`)
+	if (j < len && code[j] === "n") j++;
 	return j;
 }