gofront 1.8.0 → 1.9.1

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,18 @@ 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, 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))
+		)
 			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 });
 					}
@@ -332,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) {
@@ -424,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();
@@ -519,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",
@@ -24,6 +75,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,
@@ -129,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 ;
@@ -165,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 {
@@ -200,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;
@@ -212,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))