gofront 1.7.0 → 1.9.0

package/src/lower/ownership.js

@@ -13,6 +13,31 @@ export function rootIdentName(e) {
 	return null;
 }
 
+// True when `e` names an element of a slice or array, possibly through
+// fields (`xs[i]`, `xs[i].f.g`).
+function isElementPath(e) {
+	while (e) {
+		if (e.kind === "IndexExpr") return !e._mapValueType;
+		if (e.kind !== "SelectorExpr" && e.kind !== "ParenExpr") return false;
+		e = e.expr;
+	}
+	return false;
+}
+
+// True when `node` contains `&xs[i]` (or `&xs[i].f`): some code may then hold a
+// pointer to an element, so a whole-element store must write into it.
+export function takesElementAddress(node) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some(takesElementAddress);
+	if (
+		node.kind === "UnaryExpr" &&
+		node.op === "&" &&
+		isElementPath(node.operand)
+	)
+		return true;
+	return someChild(node, takesElementAddress);
+}
+
 // True when `node` itself (not its children) writes to variable `name`.
 export function nodeWritesVar(node, name) {
 	const root = (e) => rootIdentName(e) === name;
@@ -32,6 +57,22 @@ export function nodeWritesVar(node, name) {
 	}
 }
 
+// The variable whose address `node` takes without an explicit `&`, or null:
+// a pointer-receiver method call or method value (`v.M()`, `v.M` with
+// `func (*T) M`) takes `&v`, and slicing an array (`a[:]`) aliases it.
+export function implicitAddrRoot(node) {
+	if (node.kind === "SelectorExpr" && node._type?._ptrRecv === true)
+		return rootIdentName(node.expr);
+	if (node.kind === "SliceExpr" && isArrayTyped(node.expr?._type))
+		return rootIdentName(node.expr);
+	return null;
+}
+
+function isArrayTyped(t) {
+	while (t?.kind === "named") t = t.underlying;
+	return t?.kind === "array";
+}
+
 // 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;
@@ -43,11 +84,13 @@ export function nodeMutatesVar(node, name, addrOnly = false) {
 		rootIdentName(node.operand) === name
 	)
 		return true;
+	if (addrOnly && implicitAddrRoot(node) === name) return true;
 	if (!addrOnly && nodeWritesVar(node, name)) return true;
 	return someChild(node, (child) => nodeMutatesVar(child, name, addrOnly));
 }
 
 // Single-pass collector of all mutated or address-taken variables in an AST node.
+// With `addrOnly`, only address-taken ones, implicit address-taking included.
 export function collectMutatedVars(
 	node,
 	mutated = new Set(),
@@ -62,7 +105,10 @@ export function collectMutatedVars(
 	if (node.kind === "UnaryExpr" && node.op === "&") {
 		const root = rootIdentName(node.operand);
 		if (root) mutated.add(root);
-	} else if (!addrOnly) {
+	} else if (addrOnly) {
+		const root = implicitAddrRoot(node);
+		if (root) mutated.add(root);
+	} else {
 		if (node.kind === "AssignStmt") {
 			for (const e of node.lhs) {
 				const root = rootIdentName(e);
@@ -139,13 +185,6 @@ 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) {

package/src/lower/range.js

@@ -1,9 +1,94 @@
 // src/lower/range.js
 // Classifies for-range loop shapes and variable scoping/redelcarations.
 
-import { isNumeric } from "../typechecker/types.js";
+import { isNumeric, iteratorYieldParams } from "../typechecker/types.js";
 import { someChild } from "./walk.js";
 
+let iterStateCounter = 0;
+
+export function isIteratorRangeFor(stmt) {
+	if (stmt?.kind !== "ForStmt") return false;
+	const rangeExpr =
+		stmt.cond?.kind === "RangeExpr" ? stmt.cond : stmt.init?.rhs?.[0];
+	if (rangeExpr?.kind !== "RangeExpr") return false;
+	if (rangeExpr._isIterator) return true;
+	const iterType = rangeExpr.expr?._type;
+	return Boolean(iteratorYieldParams(iterType));
+}
+
+function buildYieldParamsAndAssignments(lhs, yieldTypes, isAssign) {
+	const params = [];
+	const assignStmts = [];
+	for (let i = 0; i < yieldTypes.length; i++) {
+		const yType = yieldTypes[i] ?? { kind: "basic", name: "any" };
+		const lhsElem = lhs[i];
+		if (!isAssign && lhsElem?.name && lhsElem.name !== "_") {
+			params.push({ name: lhsElem.name, type: yType });
+		} else {
+			const paramName = `__yield_p${i}`;
+			params.push({ name: paramName, type: yType });
+			if (isAssign && lhsElem && lhsElem.name !== "_") {
+				assignStmts.push({
+					kind: "AssignStmt",
+					lhs: [lhsElem],
+					rhs: [{ kind: "Ident", name: paramName, _type: yType }],
+					op: "=",
+				});
+			}
+		}
+	}
+	return { params, assignStmts };
+}
+
+export function getOrCreateIteratorFuncLit(stmt) {
+	if (stmt._yieldFuncLit) return stmt._yieldFuncLit;
+
+	const rangeExpr =
+		stmt.cond?.kind === "RangeExpr" ? stmt.cond : stmt.init?.rhs?.[0];
+	const iterType = rangeExpr?.expr?._type;
+	const info = iteratorYieldParams(iterType);
+	const yieldTypes = rangeExpr?._yieldParams ?? info?.yieldParams ?? [];
+
+	if (!stmt._iterStateName) {
+		stmt._iterStateName = `__iterState$${++iterStateCounter}`;
+	}
+
+	const isAssign = stmt.init?.kind === "AssignStmt";
+	const lhs = stmt.init?.lhs ?? [];
+	const { params, assignStmts } = buildYieldParamsAndAssignments(
+		lhs,
+		yieldTypes,
+		isAssign,
+	);
+
+	const rawStmts = stmt.body?.stmts ?? stmt.body?.list ?? [];
+	const bodyStmts =
+		assignStmts.length > 0 ? [...assignStmts, ...rawStmts] : rawStmts;
+
+	const funcLit = {
+		kind: "FuncLit",
+		params,
+		returnType: { kind: "basic", name: "bool" },
+		body: {
+			kind: "Block",
+			stmts: bodyStmts,
+			list: bodyStmts,
+		},
+		_type: {
+			kind: "func",
+			params: params.map((p) => p.type),
+			returns: [{ kind: "basic", name: "bool" }],
+		},
+		_isYieldClosure: true,
+		_iterStateName: stmt._iterStateName,
+		_forStmt: stmt,
+		_line: stmt._line,
+	};
+
+	stmt._yieldFuncLit = funcLit;
+	return funcLit;
+}
+
 export function isRangeFor(stmt) {
 	if (!stmt?.init) return false;
 	const init = stmt.init;

package/src/lower/reachability.js

@@ -0,0 +1,150 @@
+// src/lower/reachability.js
+// Reachability for Go-source stdlib packages: only declarations reachable
+// from user code are emitted, so an imported but unused package costs zero
+// bytes (JS output and dev-mode WASM, where Binaryen does not run).
+//
+// Stdlib top-level names are mangled (`Compare$$cmp`) and user references to
+// them are plain identifiers after type-checking, so reachability is a
+// closure over names.  A method is reachable when its receiver type is and
+// its name is selected somewhere reachable, or is called implicitly.
+
+import { forEachChild } from "./walk.js";
+
+// Methods the runtime or emitter-backed stdlib call without a selector in
+// GoFront code (fmt verbs and Fprint* writers, errors.Is/As/Unwrap,
+// encoding/json).
+const IMPLICIT_METHODS = new Set([
+	"Error",
+	"String",
+	"Write",
+	"GoString",
+	"Format",
+	"Unwrap",
+	"Is",
+	"As",
+	"MarshalJSON",
+	"UnmarshalJSON",
+	"MarshalText",
+	"UnmarshalText",
+]);
+
+function declNames(d) {
+	if (d.kind === "FuncDecl" || d.kind === "TypeDecl") return [d.name];
+	if (d.kind === "VarDecl" || d.kind === "ConstDecl")
+		return (d.decls ?? []).flatMap((spec) => spec.names ?? []);
+	return [];
+}
+
+// Names (identifiers and type names) and selected fields used under `node`.
+function collectRefs(node, names, fields) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const n of node) collectRefs(n, names, fields);
+		return;
+	}
+	if (node._stdName) names.add(node._stdName); // `cmp.Compare` in user code
+	if (
+		node.kind === "Ident" ||
+		node.kind === "TypeName" ||
+		node.kind === "GenericTypeName"
+	)
+		names.add(node.name);
+	else if (node.kind === "SelectorExpr") fields.add(node.field);
+	// A reached interface needs its methods on the types that satisfy it.
+	else if (node.kind === "InterfaceType")
+		for (const m of node.methods ?? []) fields.add(m.name);
+	forEachChild(node, (child) => collectRefs(child, names, fields));
+}
+
+function indexStdlib(stdlibPrograms) {
+	const byName = new Map(); // name -> decls
+	const methods = []; // { decl, recv }
+	const inits = new Map(); // program -> init decls
+	for (const p of stdlibPrograms) {
+		for (const d of p.decls ?? []) {
+			if (d.kind === "MethodDecl")
+				methods.push({ decl: d, recv: d.recvType?.name });
+			else if (d.kind === "FuncDecl" && d.name === "init")
+				inits.set(p, [...(inits.get(p) ?? []), d]);
+			for (const n of declNames(d)) {
+				if (!byName.has(n)) byName.set(n, []);
+				byName.get(n).push(d);
+			}
+		}
+	}
+	return { byName, methods, inits };
+}
+
+// Incremental closure over one or more Go-source stdlib packages.  A
+// declaration's body may still be unchecked (lazy checking): `decl._ensure()`,
+// when present, checks and mangles it first and returns an error text on
+// failure, so the references collected from it are the mangled ones.  Failed
+// declarations are listed in `failures`.
+export class StdlibReach {
+	constructor(stdlibPrograms) {
+		this.programs = stdlibPrograms;
+		const { byName, methods, inits } = indexStdlib(stdlibPrograms);
+		this.byName = byName;
+		this.methods = methods;
+		this.inits = inits;
+		this.reached = new Set();
+		this.names = new Set();
+		this.fields = new Set(IMPLICIT_METHODS);
+		this.pending = [];
+		this.failures = [];
+	}
+
+	// Adds `rootNodes` (AST that is emitted) and closes over what they use.
+	add(rootNodes) {
+		const roots = new Set();
+		collectRefs(rootNodes, roots, this.fields);
+		for (const n of roots) this._name(n);
+		this._close();
+	}
+
+	_name(n) {
+		if (this.names.has(n)) return;
+		this.names.add(n);
+		this.pending.push(n);
+	}
+
+	_reach(d) {
+		if (this.reached.has(d)) return;
+		this.reached.add(d);
+		const failure = d._ensure?.();
+		if (failure) this.failures.push(failure);
+		const local = new Set();
+		collectRefs(d, local, this.fields);
+		for (const n of local) this._name(n);
+	}
+
+	_close() {
+		let changed = true;
+		while (changed) {
+			while (this.pending.length > 0)
+				for (const d of this.byName.get(this.pending.pop()) ?? [])
+					this._reach(d);
+			const size = this.reached.size;
+			for (const m of this.methods)
+				if (this.names.has(m.recv) && this.fields.has(m.decl.name))
+					this._reach(m.decl);
+			for (const p of this.programs)
+				if (p.decls.some((d) => this.reached.has(d)))
+					for (const d of this.inits.get(p) ?? []) this._reach(d);
+			changed = this.reached.size !== size || this.pending.length > 0;
+		}
+	}
+}
+
+/**
+ * Returns the set of declarations of `stdlibPrograms` reachable from
+ * `rootPrograms` (all user code that is emitted).  A program's `init` is
+ * kept when anything else in that program is reached.  A reached body that
+ * fails its (lazy) check throws.
+ */
+export function reachableStdlibDecls(rootPrograms, stdlibPrograms) {
+	const reach = new StdlibReach(stdlibPrograms);
+	reach.add(rootPrograms);
+	if (reach.failures.length > 0) throw new Error(reach.failures[0]);
+	return reach.reached;
+}

package/src/lower/walk.js

@@ -23,3 +23,15 @@ export function someChild(node, pred) {
 	}
 	return false;
 }
+
+/**
+ * True when evaluating `node` runs a call or a channel receive (conversions
+ * excluded), the only operands Go still evaluates for a constant `len`.
+ */
+export function hasCallOrReceive(node) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some(hasCallOrReceive);
+	if (node.kind === "CallExpr" && !node._isTypeConversion) return true;
+	if (node.kind === "UnaryExpr" && node.op === "<-") return true;
+	return someChild(node, hasCallOrReceive);
+}

package/src/parser/declarations.js

@@ -1,4 +1,4 @@
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 
 export const declarationParseMethods = {
 	parseTopDecl() {
@@ -34,10 +34,12 @@ export const declarationParseMethods = {
 			this.expect(T.RPAREN);
 			const name = this.expect(T.IDENT).value;
 			const { params, returnType } = this.parseSignature();
+			const native = this.tokens?.natives?.get(_line - 1) ?? null;
 			const body = this.parseBlock();
 			this.semi();
 			return {
 				kind: "MethodDecl",
+				...(native && { native }),
 				recvName,
 				recvType,
 				recvPointer,
@@ -56,7 +58,15 @@ export const declarationParseMethods = {
 			typeParams = this.parseTypeParamList();
 		}
 		const { params, returnType } = this.parseSignature();
-		const body = this.parseBlock();
+		// `//gofront:intrinsic name` on the line before a body-less func: the
+		// backend provides the implementation; every pass sees an empty body.
+		const intrinsic = this.tokens?.intrinsics?.get(_line - 1) ?? null;
+		// `//gofront:native name` marks a func that keeps its Go body; a
+		// body-less one parses (and is rejected by the checker).
+		const native = this.tokens?.natives?.get(_line - 1) ?? null;
+		const bodyless =
+			(intrinsic !== null || native !== null) && !this.check(T.LBRACE);
+		const body = bodyless ? { kind: "Block", stmts: [] } : this.parseBlock();
 		this.semi();
 		return {
 			kind: "FuncDecl",
@@ -65,6 +75,8 @@ export const declarationParseMethods = {
 			params,
 			returnType,
 			body,
+			...(intrinsic && { intrinsic, _bodyless: bodyless }),
+			...(native && { native, _bodyless: bodyless }),
 			_line,
 		};
 	},
@@ -91,17 +103,46 @@ export const declarationParseMethods = {
 	// Type param lists contain IDENT followed by a constraint (another IDENT or keyword),
 	// not expressions like integers or operators.
 	_looksLikeTypeParamList() {
-		const i = this.pos + 1; // skip [
+		let i = this.pos + 1; // skip [
 		const src = this.tokens;
-		// First token must be an IDENT (the type param name)
 		if (!src[i] || src[i].type !== T.IDENT) return false;
-		// Second token should be a constraint (IDENT like 'any', 'comparable', another type name)
-		// or TILDE for union constraints
-		const second = src[i + 1];
-		if (!second) return false;
-		if (second.type === T.IDENT) return true; // T any, T Stringer
-		if (second.type === T.TILDE) return true; // T ~int
-		if (second.type === T.INTERFACE) return true; // T interface{...}
+		while (
+			src[i] &&
+			src[i].type === T.IDENT &&
+			src[i + 1] &&
+			src[i + 1].type === T.COMMA
+		) {
+			i += 2;
+		}
+		if (!src[i] || src[i].type !== T.IDENT) return false;
+		const afterName = src[i + 1];
+		if (!afterName) return false;
+		if (afterName.type === T.IDENT) return true; // T any, T Stringer
+		if (afterName.type === T.TILDE) return true; // T ~int
+		if (afterName.type === T.INTERFACE) return true; // T interface{...}
+		return false;
+	},
+
+	// `Name[…]` followed by `,` or `)` in a result list is an instantiated
+	// generic type; a result name is followed by its type (`a []int`).
+	_isGenericResultType() {
+		return this._isGenericInstanceAt(this.pos);
+	},
+
+	// True when the IDENT at `at` starts an instantiated type (`Box[int]`) that
+	// ends a list entry, rather than `name [N]T` / `name []T`.
+	_isGenericInstanceAt(at) {
+		if (this.tokens[at + 1]?.type !== T.LBRACKET) return false;
+		const src = this.tokens;
+		let depth = 0;
+		for (let i = at + 1; i < src.length; i++) {
+			const t = src[i].type;
+			if (t === T.LBRACKET) depth++;
+			else if (t === T.RBRACKET && --depth === 0) {
+				const next = src[i + 1]?.type;
+				return next === T.COMMA || next === T.RPAREN;
+			} else if (t === T.EOF || t === T.LBRACE) return false;
+		}
 		return false;
 	},
 
@@ -151,11 +192,13 @@ export const declarationParseMethods = {
 	// if a type-start token follows — if so, the IDENTs are names; if ) or ,
 	// follows, the IDENTs are themselves types.
 	_isNamedParam() {
+		if (this._isGenericInstanceAt(this.pos)) return false;
 		let pos = this.pos + 1; // skip current IDENT
 		while (
 			this.tokens[pos]?.type === T.COMMA &&
 			this.tokens[pos + 1]?.type === T.IDENT
 		) {
+			if (this._isGenericInstanceAt(pos + 1)) return false;
 			pos += 2;
 		}
 		const next = this.tokens[pos];
@@ -184,8 +227,16 @@ export const declarationParseMethods = {
 			this.check(T.EOF)
 		)
 			return null;
-		// Inside a type expression (e.g. func type in a tuple), `,` and `)` also end the type
-		if (inTypeExpr && (this.check(T.COMMA) || this.check(T.RPAREN)))
+		// Inside a type expression (e.g. func type in a tuple or a type-switch
+		// `case func():`), `,`, `)` and `:` also end the type
+		if (
+			inTypeExpr &&
+			(this.check(T.COMMA) ||
+				this.check(T.RPAREN) ||
+				this.check(T.COLON) ||
+				this.check(T.STRING) ||
+				this.check(T.ASSIGN))
+		)
 			return null;
 		// Multiple return values: (int, string) or named (result int, ok bool)
 		if (this.check(T.LPAREN)) {
@@ -195,7 +246,12 @@ export const declarationParseMethods = {
 			let isNamed = false;
 			do {
 				// Named returns: only treat IDENT as a name if peek2 is an actual type token
-				if (this.check(T.IDENT) && this.looksLikeType(this.peek2())) {
+				// (`Box[int]` is an instantiated type, not a name followed by `[int]`).
+				if (
+					this.check(T.IDENT) &&
+					this.looksLikeType(this.peek2()) &&
+					!this._isGenericResultType()
+				) {
 					names.push(this.advance().value);
 					isNamed = true;
 				} else {
@@ -204,6 +260,17 @@ export const declarationParseMethods = {
 				types.push(this.parseType());
 			} while (this.match(T.COMMA));
 			this.expect(T.RPAREN);
+			// Grouped names `(r, theta float64)`: a bare identifier before a
+			// named entry is a name sharing that entry's type.
+			if (isNamed) {
+				for (let i = types.length - 2; i >= 0; i--) {
+					if (names[i] !== null) continue;
+					if (types[i]?.kind !== "TypeName" || types[i].typeArgs?.length)
+						continue;
+					names[i] = types[i].name;
+					types[i] = { ...types[i + 1] };
+				}
+			}
 			const typeNode =
 				types.length === 1 ? types[0] : { kind: "TupleType", types };
 			// Attach named return info so typechecker can inject them into scope
@@ -261,6 +328,7 @@ export const declarationParseMethods = {
 	},
 
 	parseVarSpec() {
+		const at = this.peek();
 		const names = this.parseIdentList();
 		let type = null;
 		let value = null;
@@ -272,7 +340,7 @@ export const declarationParseMethods = {
 			type = this.parseType();
 		}
 		if (this.match(T.ASSIGN)) value = this.parseExprList();
-		return { names, type, value };
+		return { names, type, value, _line: at.line, _col: at.col };
 	},
 
 	parseConstDecl() {