gofront 1.8.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;
@@ -160,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/reachability.js

@@ -11,10 +11,12 @@
 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).
+// GoFront code (fmt verbs and Fprint* writers, errors.Is/As/Unwrap,
+// encoding/json).
 const IMPLICIT_METHODS = new Set([
 	"Error",
 	"String",
+	"Write",
 	"GoString",
 	"Format",
 	"Unwrap",
@@ -48,6 +50,9 @@ function collectRefs(node, names, fields) {
 	)
 		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));
 }
 
@@ -70,63 +75,76 @@ function indexStdlib(stdlibPrograms) {
 	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",
-];
+// 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();
+	}
 
-function addExtraRoots(names) {
-	if (names.has("strconv")) names.add("NumError$$strconv");
-	if (names.has("json")) {
-		for (const n of JSON_NAMES) names.add(n);
+	_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.
+ * kept when anything else in that program is reached.  A reached body that
+ * fails its (lazy) check throws.
  */
 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;
+	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

@@ -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,
@@ -59,7 +61,11 @@ export const declarationParseMethods = {
 		// `//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);
+		// `//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 {
@@ -70,6 +76,7 @@ export const declarationParseMethods = {
 			returnType,
 			body,
 			...(intrinsic && { intrinsic, _bodyless: bodyless }),
+			...(native && { native, _bodyless: bodyless }),
 			_line,
 		};
 	},
@@ -119,10 +126,16 @@ export const declarationParseMethods = {
 	// `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;
+		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 = this.pos + 1; i < src.length; i++) {
+		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) {
@@ -179,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];
@@ -212,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)) {

package/src/parser/expressions.js

@@ -97,6 +97,18 @@ function _isDisallowedInTypeArgs(tt) {
 	return DISALLOWED_IN_TYPE_ARGS.has(tt);
 }
 
+// `[T]` followed by `(` or a composite literal's `{` is an instantiation.  A
+// `{` after the condition of if/for/switch opens the block (`if v == s[i] {`).
+function _opensArgs(after, noCompLit) {
+	return after.type === T.LPAREN || (after.type === T.LBRACE && !noCompLit);
+}
+
+function _isCallParen(src, i, braces) {
+	return (
+		src[i].type === T.LPAREN && braces === 0 && src[i - 1]?.type === T.IDENT
+	);
+}
+
 function _isTypeIntroducerToken(tt) {
 	return (
 		tt === T.STAR ||
@@ -173,11 +185,20 @@ export const expressionParserMethods = {
 			} else if (t.type === T.LBRACKET) {
 				// Check if this looks like generic type args: Ident[Type](...)  or Ident[Type]{...}
 				// `pkg.F[int](x)` / `pkg.T[X]{...}` instantiate through a qualifier.
-				if (
-					(expr.kind === "Ident" ||
-						(expr.kind === "SelectorExpr" && expr.expr.kind === "Ident")) &&
-					this.looksLikeTypeArgList()
-				) {
+				const nameLike =
+					expr.kind === "Ident" ||
+					(expr.kind === "SelectorExpr" && expr.expr.kind === "Ident");
+				const plainArgs = nameLike && this.looksLikeTypeArgList(noCompLit);
+				const literalArgs =
+					nameLike && !plainArgs ? this.tryParseTypeLiteralArgs() : null;
+				if (literalArgs) {
+					expr = {
+						kind: "InstantiationExpr",
+						expr,
+						typeArgs: literalArgs,
+						_line: expr._line,
+					};
+				} else if (plainArgs) {
 					this.advance(); // consume [
 					const typeArgs = [this.parseType()];
 					while (this.match(T.COMMA)) typeArgs.push(this.parseType());
@@ -233,15 +254,59 @@ export const expressionParserMethods = {
 		);
 	},
 
+	// `Id[[]int, int]`, `slices.Sort[map[string]int]`: type arguments that are
+	// type literals.  Returns the parsed type list, or null (position restored)
+	// when the brackets hold an index expression such as `a[[]int{1}[0]]`.
+	tryParseTypeLiteralArgs() {
+		const first = this.peek2()?.type;
+		const startsLiteral =
+			first === T.LBRACKET || first === T.MAP || first === T.FUNC;
+		// `*T` could be a dereference in an index, but an index has no comma.
+		if (!startsLiteral && !(first === T.STAR || this._hasTopLevelComma()))
+			return null;
+		const start = this.pos;
+		try {
+			this.expect(T.LBRACKET);
+			const typeArgs = [this.parseType()];
+			while (this.match(T.COMMA)) typeArgs.push(this.parseType());
+			this.expect(T.RBRACKET);
+			if (!startsLiteral && typeArgs.length < 2) throw new Error("not types");
+			// `a[foo, bar]` is not an instantiation: names alone need a literal.
+			if (!startsLiteral && typeArgs.every((a) => a.kind === "TypeName"))
+				throw new Error("not type literals");
+			return typeArgs;
+		} catch {
+			this.pos = start;
+			return null;
+		}
+	},
+
+	// Whether the bracket pair at the current `[` contains a comma outside any
+	// nested brackets, parentheses or braces.
+	_hasTopLevelComma() {
+		let depth = 0;
+		for (let i = this.pos; i < this.tokens.length; i++) {
+			const tt = this.tokens[i].type;
+			if (tt === T.LBRACKET || tt === T.LPAREN || tt === T.LBRACE) depth++;
+			else if (tt === T.RBRACKET || tt === T.RPAREN || tt === T.RBRACE) {
+				depth--;
+				if (depth === 0) return false;
+			} else if (tt === T.COMMA && depth === 1) return true;
+			else if (tt === T.EOF) return false;
+		}
+		return false;
+	},
+
 	// Lookahead: does the [ ... ] after an Ident look like generic type args?
 	// Returns true if: only type-like tokens inside brackets, AND followed by a valid continuation
-	looksLikeTypeArgList() {
+	looksLikeTypeArgList(noCompLit = false) {
 		let i = this.pos + 1; // skip [
 		const src = this.tokens;
 		let depth = 1;
 		let hasComma = false;
 		let hasTypeKeyword = false;
 		let hasUpperIdent = false;
+		let braces = 0;
 		while (i < src.length && depth > 0) {
 			const tt = src[i].type;
 			if (tt === T.LBRACKET) {
@@ -257,6 +322,13 @@ export const expressionParserMethods = {
 				i++;
 				continue;
 			}
+			// `k.(int)` is a type assertion on a value: an index expression
+			if (tt === T.DOT && src[i + 1]?.type === T.LPAREN) return false;
+			// `uint(u)` / `f(x)`: a call or conversion is a value (a method
+			// signature inside `interface{ M() }` is the only type that has one).
+			if (tt === T.LBRACE) braces++;
+			else if (tt === T.RBRACE) braces--;
+			else if (_isCallParen(src, i, braces)) return false;
 			// Reject literals — it's an index expression
 			if (tt === T.INT || tt === T.FLOAT || tt === T.STRING) return false;
 			// Reject binary operators that wouldn't appear in type args
@@ -281,7 +353,7 @@ export const expressionParserMethods = {
 		const after = src[i + 1];
 		if (!after) return false;
 		// Call or composite lit — always valid as type args
-		if (after.type === T.LPAREN || after.type === T.LBRACE) return true;
+		if (_opensArgs(after, noCompLit)) return true;
 		// Function value in argument list: Identity[int], 99) — only if clearly a type
 		if (after.type === T.COMMA || after.type === T.RPAREN) {
 			return hasComma || hasTypeKeyword || hasUpperIdent;
@@ -307,17 +379,15 @@ export const expressionParserMethods = {
 					(t.type === T.MAP || isSliceOrArrayType) &&
 					!this.looksLikeCompositeLitArg()
 				) {
+					const start = this.pos;
 					const typeNode = this.parseType();
-					// []byte(s) / []rune(s) used as a call argument — it's a type conversion
+					// `[]byte(s)` / `[]int(nil)` is a conversion: an ordinary
+					// operand that may be compared, spread or selected from.
 					if (this.check(T.LPAREN)) {
-						this.advance();
-						const convExpr = this.parseExpr();
-						this.expect(T.RPAREN);
-						args.push({
-							kind: "TypeConversion",
-							targetType: typeNode,
-							expr: convExpr,
-						});
+						this.pos = start;
+						const arg = this.parseExpr();
+						if (this.match(T.ELLIPSIS)) arg._spread = true;
+						args.push(arg);
 					} else {
 						args.push({ kind: "TypeExpr", type: typeNode });
 					}

package/src/parser/statements.js

@@ -24,6 +24,7 @@ const ASSIGN_OPS = new Set([
 	T.PERCENT_ASSIGN,
 	T.AMP_ASSIGN,
 	T.PIPE_ASSIGN,
+	T.AND_NOT_ASSIGN,
 	T.CARET_ASSIGN,
 	T.LSHIFT_ASSIGN,
 	T.RSHIFT_ASSIGN,

package/src/parser/templ.js

@@ -10,11 +10,12 @@
 //   TemplText   { kind, value }
 //   TemplExpr   { kind, tokens }          ← raw Go token array
 //   TemplComponent { kind, tokens }       ← raw Go token array for call
-//   TemplChildren  { kind }
+//   TemplChildren  { kind, name }         ← `{ name... }`, name of a variadic slot
 //   TemplIf     { kind, condTokens, then: TemplNode[], else_: TemplNode[] | null }
 //   TemplFor    { kind, stmtTokens, body: TemplNode[] }
 //   TemplSwitch { kind, exprTokens, cases: TemplCase[] }
 //   TemplCase   { kind, caseTokens: tokens | null (null = default), body: TemplNode[] }
+//               (a `case a, b:` also carries `exprs`, one expression per value)
 //
 // Go expressions embedded in templ (`{ expr }`, attribute values, `if`
 // conditions, `switch` and `case` expressions, `@Comp(...)` calls) and `for`
@@ -71,12 +72,45 @@ function parseExprTokens(tokens, allowEmpty = true) {
 	if (allowEmpty && (!tokens || tokens.length === 0)) return { expr: null };
 	try {
 		const eofTok = new Token(T.EOF, "", 1, 1);
-		return { expr: new Parser([...tokens, eofTok]).parseExpr() };
+		const p = new Parser([...tokens, eofTok]);
+		const expr = p.parseExpr();
+		while (p.check(T.SEMICOLON)) p.advance();
+		if (!p.check(T.EOF))
+			p.err(`unexpected '${p.peek().value}' after expression`);
+		return { expr };
 	} catch (exprError) {
 		return { expr: null, exprError };
 	}
 }
 
+// Parses `tokens` as a comma-separated expression list (`case 1, 2:`). `expr`
+// and `exprError` describe the first expression (or the first error); `exprs`
+// holds every parsed expression.
+function parseExprListTokens(tokens) {
+	if (!tokens || tokens.length === 0) return { expr: null };
+	const parts = [[]];
+	let depth = 0;
+	for (const t of trimSemicolons(tokens ?? [])) {
+		if (t.type === T.LPAREN || t.type === T.LBRACKET || t.type === T.LBRACE)
+			depth++;
+		else if (
+			t.type === T.RPAREN ||
+			t.type === T.RBRACKET ||
+			t.type === T.RBRACE
+		)
+			depth--;
+		if (t.type === T.COMMA && depth === 0) parts.push([]);
+		else parts[parts.length - 1].push(t);
+	}
+	const exprs = [];
+	for (const part of parts) {
+		const parsed = parseExprTokens(part, false);
+		if (parsed.exprError) return { expr: null, exprError: parsed.exprError };
+		exprs.push(parsed.expr);
+	}
+	return { expr: exprs[0] ?? null, exprs };
+}
+
 // Parses an `if` condition; the lexer may leave the `if` keyword in front.
 function parseCondTokens(tokens) {
 	if (!tokens || tokens.length === 0) return { expr: null };
@@ -220,7 +254,10 @@ export class TemplParser extends Parser {
 				return this.templComponent(t.value);
 			case TT.TEMPL_CHILDREN:
 				this.advance();
-				return { kind: "TemplChildren" };
+				return attach(
+					{ kind: "TemplChildren", name: t.value },
+					parseExprTokens([new Token(T.IDENT, t.value, t.line, t.col)]),
+				);
 			case TT.TEMPL_IF: {
 				this.advance();
 				return this.parseTemplIf(t);
@@ -243,7 +280,9 @@ export class TemplParser extends Parser {
 	// `@templ.Raw(arg)` parses `arg`; any other component parses the whole call.
 	templComponent(tokens) {
 		const raw = isTemplRaw(tokens);
-		const parsed = parseExprTokens(raw ? tokens.slice(4, -1) : tokens);
+		const parsed = parseExprTokens(
+			raw ? trimSemicolons(tokens).slice(4, -1) : tokens,
+		);
 		return attach({ kind: "TemplComponent", tokens }, { raw, ...parsed });
 	}
 
@@ -331,7 +370,7 @@ export class TemplParser extends Parser {
 				cases.push(
 					attach(
 						{ kind: "TemplCase", caseTokens, body },
-						isDefault ? { expr: null } : parseExprTokens(caseTokens),
+						isDefault ? { expr: null } : parseExprListTokens(caseTokens),
 					),
 				);
 			} else {

package/src/parser/types.js

@@ -269,6 +269,7 @@ export const typeParserMethods = {
 					names: [],
 					type: { kind: "TypeName", name: typeName },
 					embedded: true,
+					embeddedName: typeName,
 					tag,
 				});
 				this.semi();

package/src/resolver.js

@@ -39,8 +39,7 @@ export function isBuiltinPackage(importPath) {
 }
 
 // Go-source stdlib: `stdlib/<import path>/*.go`, written in GoFront Go
-// and compiled into the caller's target.  A directory for a path that is also
-// in STDLIB_PACKAGES is an overlay: its declarations extend that namespace.
+// and compiled into the caller's target.
 const STDLIB_SOURCE_ROOT = fileURLToPath(
 	new URL("../stdlib/", import.meta.url),
 );