gofront 1.6.1 → 1.8.0

package/src/lower/ownership.js

@@ -32,6 +32,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 +59,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 +80,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);

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,132 @@
+// 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, errors.Is/As/Unwrap, encoding/json).
+const IMPLICIT_METHODS = new Set([
+	"Error",
+	"String",
+	"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);
+	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 };
+}
+
+const JSON_NAMES = [
+	"SyntaxError$$internal$jsonrt",
+	"UnmarshalTypeError$$internal$jsonrt",
+	"InvalidUnmarshalError$$internal$jsonrt",
+	"UnsupportedValueError$$internal$jsonrt",
+	"UnsupportedTypeError$$internal$jsonrt",
+	"MarshalerError$$internal$jsonrt",
+	"CheckValid$$internal$jsonrt",
+	"Number$$internal$jsonrt",
+	"OptEscapeHTML$$internal$jsonrt",
+	"OptUseNumber$$internal$jsonrt",
+	"OptDisallowUnknownFields$$internal$jsonrt",
+];
+
+function addExtraRoots(names) {
+	if (names.has("strconv")) names.add("NumError$$strconv");
+	if (names.has("json")) {
+		for (const n of JSON_NAMES) names.add(n);
+	}
+}
+
+/**
+ * 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.
+ */
+export function reachableStdlibDecls(rootPrograms, stdlibPrograms) {
+	const { byName, methods, inits } = indexStdlib(stdlibPrograms);
+	const reached = new Set();
+	const names = new Set();
+	const fields = new Set(IMPLICIT_METHODS);
+	collectRefs(rootPrograms, names, fields);
+	addExtraRoots(names);
+
+	const pending = [...names];
+	const reach = (d) => {
+		if (reached.has(d)) return;
+		reached.add(d);
+		const local = new Set();
+		collectRefs(d, local, fields);
+		for (const n of local) {
+			if (names.has(n)) continue;
+			names.add(n);
+			pending.push(n);
+		}
+	};
+	let changed = true;
+	while (changed) {
+		while (pending.length > 0)
+			for (const d of byName.get(pending.pop()) ?? []) reach(d);
+		const size = reached.size;
+		for (const m of methods)
+			if (names.has(m.recv) && fields.has(m.decl.name)) reach(m.decl);
+		for (const p of stdlibPrograms)
+			if (p.decls.some((d) => reached.has(d)))
+				for (const d of inits.get(p) ?? []) reach(d);
+		changed = reached.size !== size || pending.length > 0;
+	}
+	return reached;
+}

package/src/parser/declarations.js

@@ -1,4 +1,4 @@
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 
 export const declarationParseMethods = {
 	parseTopDecl() {
@@ -56,7 +56,11 @@ 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;
+		const bodyless = intrinsic !== null && !this.check(T.LBRACE);
+		const body = bodyless ? { kind: "Block", stmts: [] } : this.parseBlock();
 		this.semi();
 		return {
 			kind: "FuncDecl",
@@ -65,6 +69,7 @@ export const declarationParseMethods = {
 			params,
 			returnType,
 			body,
+			...(intrinsic && { intrinsic, _bodyless: bodyless }),
 			_line,
 		};
 	},
@@ -91,17 +96,40 @@ 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() {
+		if (this.peek2()?.type !== T.LBRACKET) return false;
+		const src = this.tokens;
+		let depth = 0;
+		for (let i = this.pos + 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;
 	},
 
@@ -195,7 +223,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 +237,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 +305,7 @@ export const declarationParseMethods = {
 	},
 
 	parseVarSpec() {
+		const at = this.peek();
 		const names = this.parseIdentList();
 		let type = null;
 		let value = null;
@@ -272,7 +317,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() {

package/src/parser/expressions.js

@@ -1,6 +1,6 @@
 // Parser expression methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 
 // Binary operator precedence (higher = binds tighter, matching Go spec)
 const PREC = {
@@ -108,9 +108,9 @@ function _isTypeIntroducerToken(tt) {
 }
 
 export const expressionParserMethods = {
-	parseExprList() {
-		const exprs = [this.parseExpr()];
-		while (this.match(T.COMMA)) exprs.push(this.parseExpr());
+	parseExprList(noCompLit = false) {
+		const exprs = [this.parseExpr(0, noCompLit)];
+		while (this.match(T.COMMA)) exprs.push(this.parseExpr(0, noCompLit));
 		return exprs;
 	},
 
@@ -132,7 +132,13 @@ export const expressionParserMethods = {
 		const t = this.peek();
 		if (UNARY_OPS.has(t.type)) {
 			const op = this.advance().value;
-			return { kind: "UnaryExpr", op, operand: this.parseUnary(noCompLit) };
+			return {
+				kind: "UnaryExpr",
+				op,
+				operand: this.parseUnary(noCompLit),
+				_line: t.line,
+				_col: t.col,
+			};
 		}
 		if (t.type === T.AWAIT) {
 			this.advance();
@@ -166,7 +172,12 @@ export const expressionParserMethods = {
 				}
 			} else if (t.type === T.LBRACKET) {
 				// Check if this looks like generic type args: Ident[Type](...)  or Ident[Type]{...}
-				if (expr.kind === "Ident" && this.looksLikeTypeArgList()) {
+				// `pkg.F[int](x)` / `pkg.T[X]{...}` instantiate through a qualifier.
+				if (
+					(expr.kind === "Ident" ||
+						(expr.kind === "SelectorExpr" && expr.expr.kind === "Ident")) &&
+					this.looksLikeTypeArgList()
+				) {
 					this.advance(); // consume [
 					const typeArgs = [this.parseType()];
 					while (this.match(T.COMMA)) typeArgs.push(this.parseType());
@@ -241,6 +252,8 @@ export const expressionParserMethods = {
 			if (tt === T.RBRACKET) {
 				depth--;
 				if (depth === 0) break;
+				// `a[i].F` selects from an index result: a value, never a type.
+				if (src[i + 1]?.type === T.DOT) return false;
 				i++;
 				continue;
 			}
@@ -369,7 +382,16 @@ export const expressionParserMethods = {
 		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
 			// Implicit composite literal: {X: 1} inside []Point{{X:1}} or map[string]Point{"a": {X:1}}
 			if (this.check(T.LBRACE)) {
-				elems.push(this.parseCompositeLit(null)); // null typeExpr = inferred
+				const lit = this.parseCompositeLit(null); // null typeExpr = inferred
+				if (this.match(T.COLON)) {
+					// Elided key type: map[P]int{{1}: 2}
+					const val = this.check(T.LBRACE)
+						? this.parseCompositeLit(null)
+						: this.parseExpr();
+					elems.push({ kind: "KeyValueExpr", key: lit, value: val });
+				} else {
+					elems.push(lit);
+				}
 			} else {
 				const first = this.parseExpr();
 				if (this.match(T.COLON)) {

package/src/parser/index.js

@@ -17,7 +17,7 @@
 //   CallExpr, SelectorExpr, IndexExpr, SliceExpr
 //   CompositeLit, KeyValueExpr, FuncLit, AwaitExpr
 
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 import { declarationParseMethods } from "./declarations.js";
 import { expressionParserMethods } from "./expressions.js";
 import { statementParserMethods } from "./statements.js";
@@ -131,6 +131,7 @@ export class Parser {
 			decls,
 			target: this.tokens?.target ?? null,
 			_targetDirective: this.tokens?.targetDirective ?? null,
+			_embedDirectives: this.tokens?.embedDirectives ?? [],
 			_filename: this.filename,
 			_source: this.source,
 		};

package/src/parser/statements.js

@@ -1,6 +1,6 @@
 // Parser statement methods — installed as a mixin on Parser.prototype.
 
-import { T } from "../tokens.js";
+import { T } from "../lexer/tokens.js";
 
 // Method-name dispatch for pure-delegation cases in _parseStmt.
 const PARSE_STMT_DELEGATE = {
@@ -78,6 +78,13 @@ export const statementParserMethods = {
 				this.advance();
 				this.semi();
 				return { kind: "BranchStmt", keyword: "fallthrough" };
+			case T.GOTO: {
+				// Parsed so the checker can reject it with a targeted message.
+				this.advance();
+				const label = this.expect(T.IDENT).value;
+				this.semi();
+				return { kind: "BranchStmt", keyword: "goto", label };
+			}
 			case T.GO:
 				return this.err("goroutines are not supported in GoFront");
 			case T.SELECT:
@@ -88,7 +95,12 @@ export const statementParserMethods = {
 				if (this.check2(T.COLON)) {
 					const label = this.advance().value;
 					this.advance(); // consume COLON
-					return { kind: "LabeledStmt", label, body: this.parseStmt() };
+					// A label may precede the end of a block: the statement is empty.
+					const body =
+						this.check(T.RBRACE) || this.check(T.CASE) || this.check(T.DEFAULT)
+							? { kind: "Block", stmts: [] }
+							: this.parseStmt();
+					return { kind: "LabeledStmt", label, body };
 				}
 				return this.parseSimpleStmt();
 			default:
@@ -150,27 +162,30 @@ export const statementParserMethods = {
 			};
 		}
 
-		const first = this.parseSimpleStmtRaw(true);
-
-		if (this.check(T.LBRACE)) {
-			// for k, v := range expr { }  — range stmt ends right before {
-			if (this.isRangeStmt(first)) {
+		let first = null;
+		if (!this.check(T.SEMICOLON)) {
+			first = this.parseSimpleStmtRaw(true);
+
+			if (this.check(T.LBRACE)) {
+				// for k, v := range expr { }  — range stmt ends right before {
+				if (this.isRangeStmt(first)) {
+					return {
+						kind: "ForStmt",
+						init: first,
+						cond: null,
+						post: null,
+						body: this.parseBlock(),
+					};
+				}
+				// for cond { }
 				return {
 					kind: "ForStmt",
-					init: first,
-					cond: null,
+					init: null,
+					cond: this.stmtToExpr(first),
 					post: null,
 					body: this.parseBlock(),
 				};
 			}
-			// for cond { }
-			return {
-				kind: "ForStmt",
-				init: null,
-				cond: this.stmtToExpr(first),
-				post: null,
-				body: this.parseBlock(),
-			};
 		}
 
 		this.expect(T.SEMICOLON);
@@ -180,7 +195,7 @@ export const statementParserMethods = {
 		if (!this.check(T.SEMICOLON)) cond = this.parseExpr(0, true);
 		this.expect(T.SEMICOLON);
 		let post = null;
-		if (!this.check(T.LBRACE)) post = this.parseSimpleStmtRaw();
+		if (!this.check(T.LBRACE)) post = this.parseSimpleStmtRaw(true);
 		const body = this.parseBlock();
 		return { kind: "ForStmt", init: first, cond, post, body };
 	},
@@ -290,9 +305,9 @@ export const statementParserMethods = {
 		// a, b, c := ...  or  x, y = ...
 		if (t.type === T.COMMA) {
 			const lhs = [first];
-			while (this.match(T.COMMA)) lhs.push(this.parseExpr());
+			while (this.match(T.COMMA)) lhs.push(this.parseExpr(0, noCompLit));
 			const op = this.advance(); // := or =
-			const rhs = this.parseExprList();
+			const rhs = this.parseExprList(noCompLit);
 			if (op.type === T.DEFINE) return { kind: "DefineStmt", lhs, rhs };
 			return { kind: "AssignStmt", lhs, op: "=", rhs };
 		}
@@ -300,14 +315,14 @@ export const statementParserMethods = {
 		// x := expr
 		if (t.type === T.DEFINE) {
 			this.advance();
-			const rhs = this.parseExprList();
+			const rhs = this.parseExprList(noCompLit);
 			return { kind: "DefineStmt", lhs: [first], rhs };
 		}
 
 		// x = expr  or  x += expr  etc.
 		if (ASSIGN_OPS.has(t.type)) {
 			const op = this.advance().value;
-			const rhs = this.parseExprList();
+			const rhs = this.parseExprList(noCompLit);
 			return { kind: "AssignStmt", lhs: [first], op, rhs };
 		}