gofront 1.9.0 → 1.9.2

package/src/lower/gen-types.js

@@ -59,8 +59,16 @@ export function walkNodes(root, fn) {
 	}
 	fn(root);
 	forEachChild(root, (c) => walkNodes(c, fn));
+	// templ bodies keep their Go expressions in non-enumerable properties
+	// (see parser/templ.js), which forEachChild does not visit.
+	for (const name of TEMPL_EXPR_PROPS) {
+		const d = Object.getOwnPropertyDescriptor(root, name);
+		if (d && !d.enumerable) walkNodes(d.value, fn);
+	}
 }
 
+const TEMPL_EXPR_PROPS = ["expr", "exprs", "forStmt"];
+
 // True when `t` mentions a type parameter (a generic declaration, or a type
 // built from one inside a generic function).
 export function mentionsTypeParam(t, seen = new Set()) {
@@ -126,8 +134,9 @@ export function importsFor(qualifiers) {
 
 // Every type a closed-world generator may need to describe: the entries
 // { type, node, via } for the type arguments of generic calls (`typeArg`),
-// the type of every expression (`expr`) and the package's declared named
-// types (`declared`, node null).
+// the type of every expression (`expr`), the static type of every value
+// converted to an interface (`boxed`) and the package's declared named types
+// (`declared`, node null).
 export function collectProgramTypes(programs, checker) {
 	const found = [];
 	for (const p of programs)
@@ -136,6 +145,14 @@ export function collectProgramTypes(programs, checker) {
 				found.push({ type: defaultType(a), node, via: "typeArg" });
 			if (node._type)
 				found.push({ type: defaultType(node._type), node, via: "expr" });
+			if (node._ifaceSrc)
+				found.push({ type: defaultType(node._ifaceSrc), node, via: "boxed" });
+			// A multi-value call forwarded into interfaces (`return f()`,
+			// `g(f())`) keeps one mark holder per element until lowering
+			// splits it.
+			for (const h of node._fwdIface ?? [])
+				if (h?._ifaceSrc)
+					found.push({ type: defaultType(h._ifaceSrc), node, via: "boxed" });
 		});
 	for (const [name, t] of checker.types) {
 		if (t?.kind !== "named" || t.name !== name) continue;
@@ -253,6 +270,8 @@ export class TypeSpeller {
 		const byKind = {
 			basic: () => t.name !== "void" && t.name !== "nil",
 			named: () => this.spellableNamed(t, ok, seen),
+			// A JS-interop (.d.ts) type has no Go source to write.
+			namespace: () => false,
 			pointer: () => ok(t.base),
 			slice: () => ok(t.elem),
 			array: () => ok(t.elem),

package/src/lower/index.js

@@ -16,7 +16,12 @@ import { scanAddressTaken } from "./boxing.js";
 import { analyzeCaptures } from "./captures.js";
 import { computeEmbeddedStubs } from "./embedding.js";
 import { paramEscapes } from "./escape.js";
-import { extractNamedReturns, hasDefer, normalizeDefers } from "./functions.js";
+import {
+	extractNamedReturns,
+	hasDefer,
+	normalizeDefers,
+	splitForwardedTuples,
+} from "./functions.js";
 import { computeGlobalAnalysis } from "./globals.js";
 import { OwnershipContext, takesElementAddress } from "./ownership.js";
 
@@ -83,6 +88,7 @@ export function lower(programOrPrograms, checker = null) {
 		? programOrPrograms
 		: [programOrPrograms];
 
+	splitForwardedTuples(programs);
 	normalizeDefers(programs);
 
 	res.elemAddrTaken = programs.some((p) => takesElementAddress(p?.decls));

package/src/lower/json-codecs.js

@@ -220,6 +220,8 @@ export class JsonCodecGen extends TypeSpeller {
 				return `map[${this.refl(t.key)}]${this.refl(t.value)}`;
 			case "interface":
 				return t.name === "error" ? "error" : "interface {}";
+			case "namespace":
+				return t.name;
 			case "func":
 				return this.funcString(t, (x) => this.refl(x));
 			default:
@@ -273,9 +275,49 @@ export class JsonCodecGen extends TypeSpeller {
 
 	// Statements that encode the Go expression `x` of type `t`.
 	encValue(t, x, addr) {
+		if (holdsInterop(t)) return this.encInterop(t, x);
 		return [`${this.encFn(t, addr)}(e, ${x})`];
 	}
 
+	// A JS-interop value has no Go source to spell, so it is encoded where it
+	// sits: nil is `null` (an empty slice, map or array is `[]` or `{}`), and
+	// anything else fails with the type's name.
+	encInterop(t, x) {
+		const u = under(t);
+		const fail = (name) => `\te.FailType(${q(name)})`;
+		if (u.kind === "namespace")
+			return [`if ${x} == nil {`, "\te.Null()", "} else {", fail(u.name), "}"];
+		if (u.kind === "pointer")
+			return [
+				`if ${x} == nil {`,
+				"\te.Null()",
+				"} else {",
+				fail(this.refl(t)),
+				"}",
+			];
+		const [empty, elem] =
+			u.kind === "map"
+				? ["{}", holdsInterop(u.key) ? u.key : u.value]
+				: ["[]", u.elem];
+		if (u.kind === "array")
+			return [
+				`if ${u.size} == 0 {`,
+				`\te.Lit(${q(empty)})`,
+				"} else {",
+				fail(this.refl(elem)),
+				"}",
+			];
+		return [
+			`if ${x} == nil {`,
+			"\te.Null()",
+			`} else if len(${x}) == 0 {`,
+			`\te.Lit(${q(empty)})`,
+			"} else {",
+			fail(this.refl(elem)),
+			"}",
+		];
+	}
+
 	// `mt` is the type that declares the method (the pointee for a pointer).
 	marshalCall(x, t, mt = t) {
 		if (!marshalerOf(mt) && textMarshalerOf(mt))
@@ -413,6 +455,7 @@ export class JsonCodecGen extends TypeSpeller {
 		if (u.kind === "slice" || u.kind === "map") return `len(${x}) == 0`;
 		if (u.kind === "array") return u.size === 0 ? "true" : "false";
 		if (u.kind === "struct") return "false";
+		if (u.kind === "namespace") return `${x} == nil`;
 		const n = unalias(u.name);
 		if (n === "bool") return `!${x}`;
 		if (n === "string") return `${x} == ""`;
@@ -779,6 +822,9 @@ export class JsonCodecGen extends TypeSpeller {
 
 	decStruct(u, t, typ) {
 		const fields = resolveJsonFields(u);
+		for (const f of fields)
+			if (holdsInterop(f.type))
+				throw new Error(`json: cannot unmarshal into ${interopName(f.type)}`);
 		const sname = this.shortName(t);
 		const lines = [
 			"if d.Null() {",
@@ -1106,7 +1152,8 @@ export class JsonCodecGen extends TypeSpeller {
 			this.encFn(t, false);
 		}
 		for (const { type: t, via } of this.collectedTypes()) {
-			if (via !== "declared" || mentionsTypeParam(t)) continue;
+			if (via !== "boxed" || !t || mentionsTypeParam(t)) continue;
+			if (!this.spellable(t)) continue;
 			const u = under(t);
 			if (!u || u.kind === "interface" || u.kind === "func") continue;
 			this.encFn(t, false);
@@ -1114,12 +1161,15 @@ export class JsonCodecGen extends TypeSpeller {
 		}
 	}
 
+	// A struct holding a JS-interop value (a `.d.ts` interface) cannot be
+	// written as a dynamic case, so it is not spellable either.
 	spellableNamed(t, ok) {
+		if (isJsonValue(t)) return true;
 		return (
-			isJsonValue(t) ||
-			(!t.name.includes("$$") &&
-				!t.name.includes("[") &&
-				(t.typeArgs ?? []).every(ok))
+			!t.name.includes("$$") &&
+			!t.name.includes("[") &&
+			(t.typeArgs ?? []).every(ok) &&
+			!reachesInterop(t)
 		);
 	}
 
@@ -1157,7 +1207,12 @@ export class JsonCodecGen extends TypeSpeller {
 			}
 			// Slices, arrays and maps reach an interface from any expression
 			// (a function result, a variable), not only from a literal
-			if (!buildsValue(node) && !isCompositeType(t) && !isJsonValue(t))
+			if (
+				!buildsValue(node) &&
+				!isCompositeType(t) &&
+				!isFuncComposite(t) &&
+				!isJsonValue(t)
+			)
 				continue;
 			if (this.spellable(t) && under(t)?.kind !== "interface")
 				found.set(this.key(t), t);
@@ -1196,6 +1251,48 @@ const isTaggedSlice = (t) =>
 
 // json.RawMessage and json.Number values can reach an interface from any
 // expression (a conversion, a field read).
+// True when `t` is, or holds through pointers, elements and struct fields, a
+// JS-interop type (a `.d.ts` interface) that has no Go source to spell.
+export function reachesInterop(t, seen = new Set(), viaStruct = true) {
+	if (!t || seen.has(t)) return false;
+	seen.add(t);
+	const u = under(t) ?? t;
+	switch (u.kind) {
+		case "namespace":
+			return true;
+		case "pointer":
+			return reachesInterop(u.base, seen, viaStruct);
+		case "slice":
+		case "array":
+			return reachesInterop(u.elem, seen, viaStruct);
+		case "map":
+			return (
+				reachesInterop(u.key, seen, viaStruct) ||
+				reachesInterop(u.value, seen, viaStruct)
+			);
+		case "struct":
+			return (
+				viaStruct &&
+				(u._structFields ?? []).some((f) => reachesInterop(f.type, seen))
+			);
+		default:
+			return false;
+	}
+}
+
+// True when a value of type `t` is, or holds through pointers and elements
+// (not through a named struct, which has its own codec), a JS-interop value.
+const holdsInterop = (t) => reachesInterop(t, new Set(), false);
+
+// The name of the JS-interop type that `t` is or wraps.
+function interopName(t) {
+	const u = under(t);
+	if (u.kind === "namespace") return u.name;
+	if (u.kind === "map")
+		return interopName(holdsInterop(u.key) ? u.key : u.value);
+	return interopName(u.base ?? u.elem);
+}
+
 const isJsonValue = (t) => isRaw(t) || isNumber(t);
 
 export const isCompositeType = (t) => {
@@ -1207,6 +1304,17 @@ export const isCompositeType = (t) => {
 	);
 };
 
+// A slice, array or map holding funcs: it never encodes, but a nil one in an
+// interface still does, as `null`, and a non-nil one names the func.
+export const isFuncComposite = (t) => {
+	const k = under(t)?.kind;
+	return (
+		(k === "slice" || k === "array" || k === "map") &&
+		holdsFunc(t) &&
+		!hasSharedRepr(t)
+	);
+};
+
 // Func values are not JSON-encodable, and `case []func():` does not parse.
 export function holdsFunc(t, depth = 0) {
 	if (!t || depth > 8) return false;

package/src/parser/declarations.js

@@ -227,12 +227,14 @@ export const declarationParseMethods = {
 			this.check(T.EOF)
 		)
 			return null;
-		// Inside a type expression (e.g. func type in a tuple or a type-switch
-		// `case func():`), `,`, `)` and `:` also end the type
+		// Inside a type expression (e.g. func type in a tuple, a type-switch
+		// `case func():` or a type argument `f[func(int)]`), `,`, `)`, `]` and
+		// `:` also end the type
 		if (
 			inTypeExpr &&
 			(this.check(T.COMMA) ||
 				this.check(T.RPAREN) ||
+				this.check(T.RBRACKET) ||
 				this.check(T.COLON) ||
 				this.check(T.STRING) ||
 				this.check(T.ASSIGN))

package/src/parser/expressions.js

@@ -402,48 +402,20 @@ export const expressionParserMethods = {
 		return { kind: "CallExpr", func: fn, args };
 	},
 
-	// Returns true if the current position looks like a composite literal argument,
-	// e.g. []int{1,2,3} or map[string]int{"a":1}.  We scan ahead past the type
-	// tokens to check whether a { follows, without advancing this.pos permanently.
+	// Returns true if the current position starts a composite literal argument,
+	// e.g. []int{1,2,3}, map[string]int{"a":1} or []func() int{f}: the type is
+	// parsed speculatively and must be followed by `{`.  The position is
+	// always restored.
 	looksLikeCompositeLitArg() {
-		let i = this.pos;
-		const src = this.tokens;
-		// Skip over the type tokens: [, ], map, [, K, ], V, ident, etc.
-		// Simple approach: skip until we hit something that can't be part of a type
-		let depth = 0;
-		while (i < src.length) {
-			const tt = src[i].type;
-			if (tt === T.LBRACKET) {
-				depth++;
-				i++;
-				continue;
-			}
-			if (tt === T.RBRACKET) {
-				depth--;
-				i++;
-				continue;
-			}
-			if (depth > 0) {
-				i++;
-				continue;
-			}
-			if (
-				tt === T.MAP ||
-				tt === T.IDENT ||
-				tt === T.DOT || // qualified types: []pkg.Type{...}
-				tt === T.STAR ||
-				tt === T.INT ||
-				tt === T.FLOAT ||
-				tt === T.STRING
-			) {
-				i++;
-				continue;
-			}
-			break;
+		const start = this.pos;
+		try {
+			this.parseType();
+			return this.check(T.LBRACE);
+		} catch {
+			return false;
+		} finally {
+			this.pos = start;
 		}
-		// Skip whitespace tokens (shouldn't exist post-lex, but be safe)
-		while (i < src.length && src[i].type === T.SEMICOLON) i++;
-		return i < src.length && src[i].type === T.LBRACE;
 	},
 
 	parseCompositeLit(typeExpr) {
@@ -494,7 +466,9 @@ export const expressionParserMethods = {
 		// Literals
 		if (t.type === T.INT) {
 			this.advance();
-			return { kind: "BasicLit", litKind: "INT", value: t.value };
+			const lit = { kind: "BasicLit", litKind: "INT", value: t.value };
+			if (t.rune) lit.rune = true;
+			return lit;
 		}
 		if (t.type === T.FLOAT) {
 			this.advance();
@@ -589,6 +563,16 @@ export const expressionParserMethods = {
 			return this.parseCompositeLit(typeExpr);
 		}
 
+		// Interface conversion: interface{ M() }(v).  `interface{…}{` is not a
+		// composite literal in Go, so only the conversion form is accepted.
+		if (t.type === T.INTERFACE) {
+			const targetType = this.parseInterfaceType();
+			this.expect(T.LPAREN);
+			const expr = this.parseExpr();
+			this.expect(T.RPAREN);
+			return { kind: "TypeConversion", targetType, expr };
+		}
+
 		if (t.type === T.CHAN) {
 			this.err("channels are not supported in GoFront");
 		}

package/src/parser/statements.js

@@ -2,6 +2,57 @@
 
 import { T } from "../lexer/tokens.js";
 
+// Statement keywords: none of them can appear inside a composite literal or a
+// statement header's expressions.
+const STMT_KEYWORDS = new Set([
+	T.VAR,
+	T.CONST,
+	T.TYPE,
+	T.IF,
+	T.ELSE,
+	T.FOR,
+	T.RETURN,
+	T.BREAK,
+	T.CONTINUE,
+	T.SWITCH,
+	T.CASE,
+	T.DEFAULT,
+	T.SELECT,
+	T.DEFER,
+	T.GO,
+	T.FALLTHROUGH,
+]);
+
+// Tokens that only appear in statements: a brace pair holding one at its top
+// level is a block, not a composite literal.
+const STMT_ONLY_TOKENS = new Set([
+	...STMT_KEYWORDS,
+	T.SEMICOLON,
+	T.ASSIGN,
+	T.DEFINE,
+	T.PLUS_ASSIGN,
+	T.MINUS_ASSIGN,
+	T.STAR_ASSIGN,
+	T.SLASH_ASSIGN,
+	T.PERCENT_ASSIGN,
+	T.AMP_ASSIGN,
+	T.PIPE_ASSIGN,
+	T.AND_NOT_ASSIGN,
+	T.CARET_ASSIGN,
+	T.LSHIFT_ASSIGN,
+	T.RSHIFT_ASSIGN,
+	T.INC,
+	T.DEC,
+]);
+
+const OPEN_BRACKETS = new Set([T.LBRACE, T.LPAREN, T.LBRACKET]);
+const CLOSE_BRACKETS = new Set([T.RBRACE, T.RPAREN, T.RBRACKET]);
+
+function bracketDelta(tt) {
+	if (OPEN_BRACKETS.has(tt)) return 1;
+	return CLOSE_BRACKETS.has(tt) ? -1 : 0;
+}
+
 // Method-name dispatch for pure-delegation cases in _parseStmt.
 const PARSE_STMT_DELEGATE = {
 	[T.VAR]: "parseVarDecl",
@@ -130,6 +181,7 @@ export const statementParserMethods = {
 		let cond;
 		// if init; cond { } — use noCompLit to avoid "{" being parsed as composite literal
 		const first = this.parseSimpleStmtRaw(true);
+		this._rejectHeaderCompositeLit("if", 0, first);
 		// Only treat as "init; cond" if semicolon is followed by a non-brace token
 		if (this.check(T.SEMICOLON) && this.peek2().type !== T.LBRACE) {
 			this.advance(); // consume ;
@@ -166,6 +218,7 @@ export const statementParserMethods = {
 		let first = null;
 		if (!this.check(T.SEMICOLON)) {
 			first = this.parseSimpleStmtRaw(true);
+			this._rejectHeaderCompositeLit("for", 1, first);
 
 			if (this.check(T.LBRACE)) {
 				// for k, v := range expr { }  — range stmt ends right before {
@@ -201,6 +254,59 @@ export const statementParserMethods = {
 		return { kind: "ForStmt", init: first, cond, post, body };
 	},
 
+	// `if s := &T{f: 1}; s.f > 0 {`: in a header, `{` after a type name opens
+	// the body, so Go requires the literal to be parenthesized.  Reported when
+	// the brace pair holds no statement tokens, is followed by an explicit `;`,
+	// and the header then continues to its body `{` (with at most `semis`
+	// further `;`, one for a `for` post statement).  A bare expression or a
+	// range clause before the `{` (`if ok { f() };`) means it is the body.
+	_rejectHeaderCompositeLit(keyword, semis, first) {
+		if (!this.check(T.LBRACE)) return;
+		if (first?.kind === "ExprStmt" || this.isRangeStmt(first)) return;
+		const prev = this.tokens[this.pos - 1]?.type;
+		if (prev !== T.IDENT && prev !== T.RBRACKET) return;
+		const close = this._closingBrace(this.pos);
+		if (close < 0) return;
+		const semi = this.tokens[close + 1];
+		if (semi?.type !== T.SEMICOLON || !this._isExplicitSemi(semi)) return;
+		if (!this._headerContinues(close + 2, semis)) return;
+		this.err(`composite literal in ${keyword} header must be parenthesized`);
+	},
+
+	// Index of the `}` matching the `{` at `open`, or -1 when the pair holds a
+	// statement-only token at its top level (then it is a block).
+	_closingBrace(open) {
+		let depth = 0;
+		for (let i = open; i < this.tokens.length; i++) {
+			const tt = this.tokens[i].type;
+			depth += bracketDelta(tt);
+			if (depth === 0) return tt === T.RBRACE ? i : -1;
+			if (tt === T.EOF || (depth === 1 && STMT_ONLY_TOKENS.has(tt))) return -1;
+		}
+		return -1;
+	},
+
+	_isExplicitSemi(tok) {
+		if (!this.source) return false;
+		this._sourceLines ??= this.source.split("\n");
+		return this._sourceLines[tok.line - 1]?.[tok.col - 1] === ";";
+	},
+
+	// Whether the tokens from `i` reach a top-level `{` (the body) without a
+	// statement keyword and with at most `semis` semicolons on the way.
+	_headerContinues(i, semis) {
+		let depth = 0;
+		for (; i < this.tokens.length; i++) {
+			const tt = this.tokens[i].type;
+			if (tt === T.LBRACE && depth === 0) return true;
+			depth += bracketDelta(tt);
+			if (tt === T.SEMICOLON && depth === 0) semis--;
+			if (depth < 0 || semis < 0) return false;
+			if (tt === T.EOF || STMT_KEYWORDS.has(tt)) return false;
+		}
+		return false;
+	},
+
 	isRangeStmt(stmt) {
 		if (!stmt) return false;
 		if (stmt.kind !== "DefineStmt" && stmt.kind !== "AssignStmt") return false;
@@ -213,6 +319,7 @@ export const statementParserMethods = {
 		let tag = null;
 		if (!this.check(T.LBRACE)) {
 			const first = this.parseSimpleStmtRaw(true);
+			this._rejectHeaderCompositeLit("switch", 0, first);
 			if (this.match(T.SEMICOLON)) {
 				init = first;
 				if (!this.check(T.LBRACE))

package/src/parser/types.js

@@ -329,6 +329,17 @@ export const typeParserMethods = {
 				this.semi();
 				continue;
 			}
+			// Type-set element that is not a bare name: *T, []int, map[K]V, ...
+			if (!this.check(T.IDENT)) {
+				const terms = [{ approx: false, type: this.parseType() }];
+				while (this.match(T.PIPE)) {
+					const approx = this.match(T.TILDE);
+					terms.push({ approx, type: this.parseType() });
+				}
+				unionConstraint = { kind: "UnionConstraint", terms };
+				this.semi();
+				continue;
+			}
 			const name = this.expect(T.IDENT).value;
 			if (this.check(T.LPAREN)) {
 				// Method signature: Name(params) returnType