gofront 1.3.4 → 1.3.6

package/src/codegen/statements.js

@@ -1,6 +1,6 @@
 // CodeGen statement methods — installed as a mixin on CodeGen.prototype.
 
-import { isComplex } from "../typechecker/types.js";
+import { isComplex, isNumeric } from "../typechecker/types.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
@@ -122,14 +122,20 @@ export const statementGenMethods = {
 
 	_genDefineMixedRedecl(lhs, rhs, redecls) {
 		if (rhs.length === 1 && lhs.length > 1) {
-			const tmp = "__t";
-			this.line(`let ${tmp} = ${rhs[0]};`);
+			this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+			const tmp = `__t${this._tmpCounter}`;
+			this.line(`const ${tmp} = ${rhs[0]};`);
 			for (let i = 0; i < lhs.length; i++) {
+				if (lhs[i] === "_") continue;
 				const prefix = redecls[i] ? "" : "let ";
 				this.line(`${prefix}${lhs[i]} = ${tmp}[${i}];`);
 			}
 		} else {
 			for (let i = 0; i < lhs.length; i++) {
+				if (lhs[i] === "_") {
+					this.line(`${rhs[i]};`);
+					continue;
+				}
 				const prefix = redecls[i] ? "" : "let ";
 				this.line(`${prefix}${lhs[i]} = ${rhs[i]};`);
 			}
@@ -142,7 +148,13 @@ export const statementGenMethods = {
 			this._genCommaOkMapIndex(stmt, rhsNode, true);
 			return;
 		}
-		const rhs = stmt.rhs.map((e) => this.genExpr(e));
+		const paired = stmt.rhs.length === stmt.lhs.length;
+		const rhs = stmt.rhs.map((e, i) => {
+			const l = paired ? stmt.lhs[i] : null;
+			if (!l || l.name === "_") return this.genExpr(e);
+			if (l._redecl) return this.genValueExpr(e);
+			return this._genDeclValue(l.name, e);
+		});
 		const lhs = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
 		const redecls = stmt.lhs.map((e) => !!e._redecl);
 		const anyRedecl = redecls.some((r) => r);
@@ -150,7 +162,8 @@ export const statementGenMethods = {
 			this._genDefineSingleVar(lhs, rhs, redecls);
 		} else if (!anyRedecl) {
 			const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
-			this.line(`let [${lhs.join(", ")}] = ${rhsStr};`);
+			const names = lhs.map((n) => (n === "_" ? "" : n));
+			this.line(`let [${names.join(", ")}] = ${rhsStr};`);
 		} else {
 			this._genDefineMixedRedecl(lhs, rhs, redecls);
 		}
@@ -218,7 +231,12 @@ export const statementGenMethods = {
 			this._genStructDerefAssign(stmt);
 			return;
 		}
-		const rhs = stmt.rhs.map((e) => this.genExpr(e));
+		const paired = stmt.rhs.length === stmt.lhs.length && stmt.op === "=";
+		const rhs = stmt.rhs.map((e, i) =>
+			paired && stmt.lhs[i].name !== "_"
+				? this.genValueExpr(e)
+				: this.genExpr(e),
+		);
 		this._markIndexLvalues(stmt.lhs);
 		const lhs = stmt.lhs.map((e) => this._genAssignLhsExpr(e));
 		const pairs = lhs.map((l, i) => ({ l, r: rhs[i] ?? rhs[0] }));
@@ -243,7 +261,14 @@ export const statementGenMethods = {
 
 	_genStructDerefAssign(stmt) {
 		const target = this.genExpr(stmt.lhs[0].operand);
-		const source = this.genExpr(stmt.rhs[0]);
+		const rhsNode = stmt.rhs[0];
+		const fields = this._aggregateBase(rhsNode._type)?.fields;
+		const shallowOk =
+			fields instanceof Map &&
+			![...fields.values()].some((t) => this._aggregateBase(t));
+		const source = shallowOk
+			? this.genExpr(rhsNode)
+			: this.genValueExpr(rhsNode);
 		this.line(`Object.assign(${target}, ${source});`);
 	},
 
@@ -293,7 +318,7 @@ export const statementGenMethods = {
 		}
 		const vals =
 			stmt.values.length > 0
-				? stmt.values.map((v) => this.genExpr(v))
+				? stmt.values.map((v) => this._genReturnValue(v))
 				: (this.namedReturnVars ?? []);
 		const stored = vals.length === 1 ? vals[0] : `[${vals.join(", ")}]`;
 		this.line(
@@ -318,10 +343,10 @@ export const statementGenMethods = {
 				this.line("return;");
 			}
 		} else if (stmt.values.length === 1) {
-			this.line(`return ${this.genExpr(stmt.values[0])};`);
+			this.line(`return ${this._genReturnValue(stmt.values[0])};`);
 		} else {
 			this.line(
-				`return [${stmt.values.map((v) => this.genExpr(v)).join(", ")}];`,
+				`return [${stmt.values.map((v) => this._genReturnValue(v)).join(", ")}];`,
 			);
 		}
 	},
@@ -425,12 +450,7 @@ export const statementGenMethods = {
 	},
 
 	_isIntRangeType(iterType) {
-		return (
-			(iterType?.kind === "basic" &&
-				(iterType.name === "int" || iterType.name === "float64")) ||
-			(iterType?.kind === "untyped" &&
-				(iterType.base === "int" || iterType.base === "float64"))
-		);
+		return isNumeric(iterType);
 	},
 
 	_isMapRangeType(iterType) {
@@ -447,47 +467,152 @@ export const statementGenMethods = {
 		);
 	},
 
-	_emitSliceLoopHeader(rawIdx, iteree, isAssign, d) {
+	_rangeVarTarget(e, isAssign) {
+		if (e.kind === "Ident") {
+			if (e.name === "_") return null;
+			const boxed = this._boxedVars.has(e.name);
+			if (isAssign) return boxed ? `${e.name}.value = ` : `${e.name} = `;
+			return boxed ? { name: e.name, boxed } : { name: e.name };
+		}
+		this._markIndexLvalues([e]);
+		return `${this._genAssignLhsExpr(e)} = `;
+	},
+
+	_emitRangeVar(e, valueJs, isAssign) {
+		if (!e) return;
+		const target = this._rangeVarTarget(e, isAssign);
+		if (target === null) return;
+		if (typeof target === "string") {
+			this.line(`${target}${valueJs};`);
+			return;
+		}
+		const v = target.boxed ? `{ value: ${valueJs} }` : valueJs;
+		this.line(`let ${target.name} = ${v};`);
+	},
+
+	// True when the body re-declares one of `names` at its top level (legal Go shadowing).
+	_bodyRedeclares(body, names) {
+		if (names.length === 0) return false;
+		for (const s of body.stmts ?? []) {
+			if (s.kind === "DefineStmt" && s.lhs.some((e) => names.includes(e.name)))
+				return true;
+			if (
+				(s.kind === "VarDecl" || s.kind === "ConstDecl") &&
+				s.decls?.some((d) => d.names?.some((n) => names.includes(n)))
+			)
+				return true;
+		}
+		return false;
+	},
+
+	// Range value variable: aliases the element unless the body writes the variable or the collection.
+	_rangeElemValue(stmt, valNode, js, isAssign) {
+		const iterNode = stmt.init.rhs[0].expr;
+		const iterType = iterNode._type;
+		const base = iterType?.kind === "named" ? iterType.underlying : iterType;
+		const elemType = base?.elem;
+		if (!valNode || !this._aggregateBase(elemType)) return js;
+		if (isAssign || valNode.kind !== "Ident")
+			return this._cloneJs(elemType, js);
+		if (valNode.name === "_") return js;
+		const root = this._rootIdentName(iterNode);
+		const mutated =
+			this._fnMutates(valNode.name) ||
+			(root !== null && this._nodeMutatesVar(stmt.body, root));
+		this._markOwnership(valNode.name, mutated);
+		return mutated ? this._cloneJs(elemType, js) : js;
+	},
+
+	_genSliceRangeFor(stmt, iteree, isAssign) {
+		this._loopDepth = this._loopDepth ?? 0;
+		const d = this._loopDepth++;
+		const [idxNode, valNode] = stmt.init.lhs;
+		const i = `__i${d}`;
 		const arr = `__arr${d}`;
 		const len = `__len${d}`;
-		const hasIdx = rawIdx && rawIdx !== "_";
-		if (isAssign && hasIdx) {
-			this.line(`const ${arr} = ${iteree};`);
-			this.line(`const ${len} = ${arr} ? ${arr}.length : 0;`);
-			this.line(`for (${rawIdx} = 0; ${rawIdx} < ${len}; ${rawIdx}++) {`);
-		} else {
-			const idx = hasIdx ? rawIdx : `__i${d}`;
-			this.line(
-				`for (let ${idx} = 0, ${arr} = ${iteree}, ${len} = ${arr} ? ${arr}.length : 0; ${idx} < ${len}; ${idx}++) {`,
+		this.line(
+			`for (let ${i} = 0, ${arr} = ${iteree}, ${len} = ${arr} ? ${arr}.length : 0; ${i} < ${len}; ${i}++) {`,
+		);
+		this.indented(() => {
+			this._emitRangeVar(idxNode, i, isAssign);
+			this._emitRangeVar(
+				valNode,
+				this._rangeElemValue(stmt, valNode, `${arr}[${i}]`, isAssign),
+				isAssign,
 			);
-		}
+			const declared = isAssign
+				? []
+				: [idxNode, valNode]
+						.filter((e) => e?.kind === "Ident" && e.name !== "_")
+						.map((e) => e.name);
+			if (this._bodyRedeclares(stmt.body, declared)) {
+				this.line("{");
+				this.indented(() => this.genBlock(stmt.body));
+				this.line("}");
+			} else {
+				this.genBlock(stmt.body);
+			}
+		});
+		this.line("}");
+		this._loopDepth--;
 	},
 
-	_emitSliceValAssign(rawIdx, rawVal, isAssign, d) {
-		if (!rawVal || rawVal === "_") return;
-		const idx = rawIdx && rawIdx !== "_" ? rawIdx : `__i${d}`;
-		const kw = isAssign ? "" : "let ";
-		this.line(`${kw}${rawVal} = __arr${d}[${idx}];`);
+	// Whether `for i := range n` can be emitted as a plain `for (let i = 0; …)` without hidden registers.
+	_isSimpleIntRange(stmt, name, isAssign) {
+		if (isAssign) return false;
+		if (!name || name === "_") return true;
+		return !this._boxedVars.has(name) && !this._nodeAssigns(stmt.body, name);
 	},
 
-	_genSliceRangeFor(stmt, iteree, lhs, isAssign) {
+	_genIntRangeBody(stmt, name, isAssign) {
+		const wrap = !isAssign && name && this._bodyRedeclares(stmt.body, [name]);
+		if (!wrap) return this.genBlock(stmt.body);
+		this.line("{");
+		this.indented(() => this.genBlock(stmt.body));
+		this.line("}");
+	},
+
+	_genIntRangeFor(stmt, iteree, isAssign) {
+		const varNode = stmt.init.lhs[0];
+		const name = varNode?.kind === "Ident" ? varNode.name : null;
+		if (this._isSimpleIntRange(stmt, name, isAssign)) {
+			const v = !name || name === "_" ? "_$" : name;
+			this.line(`for (let ${v} = 0; ${v} < ${iteree}; ${v}++) {`);
+			this.indented(() => this.genBlock(stmt.body));
+			this.line("}");
+			return;
+		}
 		this._loopDepth = this._loopDepth ?? 0;
-		const d = this._loopDepth;
-		this._loopDepth++;
-		this._emitSliceLoopHeader(lhs[0], iteree, isAssign, d);
+		const d = this._loopDepth++;
+		const i = `__i${d}`;
+		const n = `__n${d}`;
+		this.line(`for (let ${i} = 0, ${n} = ${iteree}; ${i} < ${n}; ${i}++) {`);
 		this.indented(() => {
-			this._emitSliceValAssign(lhs[0], lhs[1], isAssign, d);
-			this.genBlock(stmt.body);
+			this._emitRangeVar(varNode, i, isAssign);
+			this._genIntRangeBody(stmt, name, isAssign);
 		});
 		this.line("}");
 		this._loopDepth--;
 	},
 
-	_genIntRangeFor(rawVar, iteree, body) {
-		const v = rawVar === "_" ? "_$" : rawVar;
-		this.line(`for (let ${v} = 0; ${v} < ${iteree}; ${v}++) {`);
-		this.indented(() => this.genBlock(body));
-		this.line("}");
+	// True when `node` contains an assignment or ++/-- targeting identifier `name`.
+	_nodeAssigns(node, name) {
+		if (!node || typeof node !== "object") return false;
+		if (Array.isArray(node))
+			return node.some((n) => this._nodeAssigns(n, name));
+		if (
+			(node.kind === "AssignStmt" &&
+				node.lhs.some((e) => e.kind === "Ident" && e.name === name)) ||
+			(node.kind === "IncDecStmt" &&
+				node.expr.kind === "Ident" &&
+				node.expr.name === name)
+		)
+			return true;
+		for (const key of Object.keys(node)) {
+			if (key.startsWith("_")) continue;
+			if (this._nodeAssigns(node[key], name)) return true;
+		}
+		return false;
 	},
 
 	_genIterFor(init, iterType, iteree, lhs, body) {
@@ -515,12 +640,12 @@ export const statementGenMethods = {
 			: this.genExpr(range.expr);
 
 		if (lhs.length <= 1 && this._isIntRangeType(iterType)) {
-			this._genIntRangeFor(lhs[0], iteree, stmt.body);
+			this._genIntRangeFor(stmt, iteree, init.kind === "AssignStmt");
 			return;
 		}
 
 		if (!this._isMapRangeType(iterType) && !this._isStringRangeType(iterType)) {
-			this._genSliceRangeFor(stmt, iteree, lhs, init.kind === "AssignStmt");
+			this._genSliceRangeFor(stmt, iteree, init.kind === "AssignStmt");
 			return;
 		}
 

package/src/codegen/stdlib/builder.js

@@ -28,12 +28,17 @@ const BUILDER_COMMON = {
 export const builderMethods = {
 	_genBuilderCall(typeName, method, expr) {
 		const recv = expr.func.expr;
-		const recvJs = this.genExpr(recv);
-		const base = `(${recvJs}?.value ?? ${recvJs})`;
+		const base = this._unboxWriter(this.genExpr(recv));
 		const args = expr.args.map((a) => this.genExpr(a));
 		const isStr = typeName === "strings.Builder";
 		const table = isStr ? BUILDER_STR : BUILDER_BYTES;
 		const gen = table[method] ?? BUILDER_COMMON[method];
 		return gen ? gen(base, args) : undefined;
 	},
+
+	// Accepts a Builder/Buffer or a pointer box around one; evaluates `js` once.
+	_unboxWriter(js) {
+		if (/^[\w$.]+$/.test(js)) return `(${js}?.value ?? ${js})`;
+		return `((__w) => __w?.value ?? __w)(${js})`;
+	},
 };

package/src/codegen/stdlib/fmt.js

@@ -80,12 +80,12 @@ export const fmtMethods = {
 		const sprintfCall = this._buildFprintSprintfCall(fn, rest.length, restJs);
 		if (targetTypeName === "strings.Builder") {
 			const w = this.genExpr(writerArg);
-			const base = `(${w}?.value ?? ${w})`;
+			const base = this._unboxWriter(w);
 			return `(${base}._buf += ${sprintfCall})`;
 		}
 		if (targetTypeName === "bytes.Buffer") {
 			const w = this.genExpr(writerArg);
-			const base = `(${w}?.value ?? ${w})`;
+			const base = this._unboxWriter(w);
 			return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${sprintfCall})`;
 		}
 		// Generic io.Writer fallback — call .WriteString if available

package/src/codegen/stdlib/io.js

@@ -14,7 +14,7 @@ export const ioMethods = {
 					(writerType?.kind === "pointer" ? writerType.base?.name : null);
 				const w = this.genExpr(writerArg);
 				const s = this.genExpr(expr.args[1]);
-				const base = `(${w}?.value ?? ${w})`;
+				const base = this._unboxWriter(w);
 				if (typeName === "strings.Builder") {
 					return `((b,s) => { b._buf += s; return [s.length, null]; })(${base}, ${s})`;
 				}

package/src/dev-server.js

@@ -140,13 +140,15 @@ function isInsideDir(root, target) {
 	return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
 }
 
-function handleSseRequest(req, res, clients) {
+function handleSseRequest(req, res, clients, lastError = null) {
 	res.writeHead(200, {
 		"Content-Type": "text/event-stream",
 		"Cache-Control": "no-cache",
 		Connection: "keep-alive",
 	});
 	res.write(": connected\n\n");
+	if (lastError)
+		res.write(`event: build-error\ndata: ${JSON.stringify(lastError)}\n\n`);
 	clients.add(res);
 	req.on?.("close", () => clients.delete(res));
 }
@@ -216,7 +218,7 @@ export function handleDevRequest(
 	options = {},
 ) {
 	if (req.url === "/_gofront/events") {
-		handleSseRequest(req, res, clients);
+		handleSseRequest(req, res, clients, options.getLastError?.() ?? null);
 		return;
 	}
 
@@ -312,15 +314,19 @@ function closeServer(server, clients, timer) {
 export function createDevServer(serveDir, port = 3000, options = {}) {
 	const clients = new Set();
 	const heartbeatMs = options.heartbeatInterval ?? 15000;
+	const host = options.host ?? "localhost";
+	// Kept so browsers that connect (or reload) after a failed build still see the overlay.
+	let lastError = null;
+	const requestOptions = { ...options, getLastError: () => lastError };
 
 	const server = createServer((req, res) => {
-		handleDevRequest(req, res, serveDir, clients, options);
+		handleDevRequest(req, res, serveDir, clients, requestOptions);
 	});
 
 	server.on("error", (err) => handleServerError(err, port));
-	server.listen(port, () => {
+	server.listen(port, host, () => {
 		const actualPort = server.address()?.port ?? port;
-		if (port !== 0) {
+		if (port !== 0 && !options.silent) {
 			console.error(`gofront: dev server → http://localhost:${actualPort}`);
 		}
 	});
@@ -329,17 +335,23 @@ export function createDevServer(serveDir, port = 3000, options = {}) {
 		heartbeatMs > 0 ? setInterval(() => sendPings(clients), heartbeatMs) : null;
 	heartbeatTimer?.unref?.();
 
-	const notify = createNotify(clients);
+	const broadcastNotify = createNotify(clients);
+	const notify = (arg) => {
+		if (!arg?.type) lastError = null;
+		broadcastNotify(arg);
+	};
+	const notifyError = (err) => {
+		lastError = buildErrorPayload(err);
+		broadcastToClients(clients, "build-error", lastError);
+	};
 
 	return {
 		broadcast: (event, data) => broadcastToClients(clients, event, data),
 		notify,
 		notifyCss: (file) =>
 			broadcastToClients(clients, "css-update", { type: "css-update", file }),
-		notifyError: (err) =>
-			broadcastToClients(clients, "build-error", buildErrorPayload(err)),
-		notifyBuildError: (err) =>
-			broadcastToClients(clients, "build-error", buildErrorPayload(err)),
+		notifyError,
+		notifyBuildError: notifyError,
 		ping: () => sendPings(clients),
 		clients,
 		server,

package/src/index.js

@@ -162,8 +162,14 @@ if (args[0] === "dev") {
 	const devOptions = parseDevArgs(args.slice(1));
 	try {
 		const dev = await handleDev(devOptions.targetDir, devOptions);
-		const port = dev.port ?? devOptions.port ?? 3000;
-		console.error(`gofront: dev server running → http://localhost:${port}`);
+		if (dev.initialError) {
+			console.error("gofront: ERROR");
+			for (const line of dev.initialError.message.split("\n"))
+				console.error(`  ${line}`);
+		} else {
+			console.error(`gofront: OK — wrote ${dev.outputFile}`);
+		}
+		console.error(`gofront: dev server running → http://localhost:${dev.port}`);
 		console.error(`gofront: watching ${dev.srcDir} for changes...`);
 
 		const shutdown = async () => {

package/src/parser/declarations.js

@@ -29,7 +29,7 @@ export const declarationParseMethods = {
 				this.check(T.IDENT) && !this.isReceiverTerminator(this.peek2())
 					? this.advance().value
 					: "_";
-			this.match(T.STAR); // pointer receiver: (c *Counter) — strip *, treat same as value receiver
+			const recvPointer = Boolean(this.match(T.STAR));
 			const recvType = this.parseTypeName();
 			this.expect(T.RPAREN);
 			const name = this.expect(T.IDENT).value;
@@ -40,6 +40,7 @@ export const declarationParseMethods = {
 				kind: "MethodDecl",
 				recvName,
 				recvType,
+				recvPointer,
 				name,
 				params,
 				returnType,

package/src/pwa.js

@@ -86,7 +86,9 @@ self.addEventListener("fetch", (event) => {
 				return response;
 			}).catch(() => {
 				if (event.request.headers?.get?.("accept")?.includes("text/html")) {
-					return caches.match("./") || caches.match("./index.html");
+					return caches
+						.match("./")
+						.then((r) => r || caches.match("./index.html"));
 				}
 			});
 		}),

package/src/typechecker/assignability.js

@@ -14,6 +14,7 @@ import {
 	isNumeric,
 	isPointer,
 	isString,
+	isTypedArraySlice,
 	isUntyped,
 	LOG_OPS,
 	SIZED_FLOAT_NAMES,
@@ -157,6 +158,7 @@ export const assignabilityMethods = {
 		if (!target || !source) return;
 		target = this.resolveType(target);
 		source = this.resolveType(source);
+		this._markIfaceBox(target, source, node);
 		if (this._assertAssignableEarlyReturn(target, source)) return;
 		if (isPointer(target) && isPointer(source)) {
 			this.assertAssignable(
@@ -170,10 +172,34 @@ export const assignabilityMethods = {
 		if (this._isNumericCoercible(target, source)) return;
 		if (this._checkArrayAssignable(target, source, node)) return;
 		if (this._checkTypedArrayAssignable(target, source, node)) return;
+		if (this._checkFuncAssignable(target, source, node)) return;
 		if (typeStr(target) !== typeStr(source))
 			this._assertAssignableTypeMismatch(target, source, node);
 	},
 
+	// Tags struct values / struct pointers flowing into an interface so codegen can
+	// tell `T` from `*T` at runtime (both compile to the same class instance).
+	_markIfaceBox(target, source, node) {
+		if (this._skipIfaceMark) return;
+		if (!node || typeof node !== "object" || !target || !source) return;
+		if (target.kind === "typeParam") return;
+		const tBase = this.resolveType(
+			target.kind === "named" ? target.underlying : target,
+		);
+		if (!isAny(target) && tBase?.kind !== "interface") return;
+		const structOf = (t) => {
+			const r = this.resolveType(t);
+			const b = r?.kind === "named" ? this.resolveType(r.underlying) : r;
+			return b?.kind === "struct";
+		};
+		const sBase = this.resolveType(
+			source.kind === "named" ? source.underlying : source,
+		);
+		if (sBase?.kind === "struct") node._ifaceBox = "value";
+		else if (sBase?.kind === "pointer" && structOf(sBase.base))
+			node._ifaceBox = "ptr";
+	},
+
 	_assertAssignableEarlyReturn(target, source) {
 		return (
 			target?.kind === "typeParam" ||
@@ -211,9 +237,13 @@ export const assignabilityMethods = {
 
 	_isNumericCoercible(target, source) {
 		if (target.kind !== "basic" || source.kind !== "basic") return false;
+		const pair = `${target.name}:${source.name}`;
 		return (
-			(target.name === "float64" && source.name === "int") ||
-			(target.name === "int" && source.name === "float64")
+			pair === "float64:int" ||
+			pair === "int:float64" ||
+			// rune was historically int in GoFront; keep rune/int interchangeable.
+			pair === "int:int32" ||
+			pair === "int32:int"
 		);
 	},
 
@@ -258,8 +288,9 @@ export const assignabilityMethods = {
 			const taElem = targetTa
 				? (target.underlying?._elemType ?? target._elemType)
 				: (source.underlying?._elemType ?? source._elemType);
-			const slElem = targetSlice ? targetSlice.elem : sourceSlice.elem;
-			if (typeStr(taElem) === typeStr(slElem)) return true;
+			const slice = targetSlice ?? sourceSlice;
+			if (isTypedArraySlice(slice) && typeStr(taElem) === typeStr(slice.elem))
+				return true;
 			this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
 			return true;
 		}
@@ -275,6 +306,21 @@ export const assignabilityMethods = {
 		return false;
 	},
 
+	_checkFuncAssignable(target, source, node) {
+		const tFunc = target.kind === "named" ? target.underlying : target;
+		const sFunc = source.kind === "named" ? source.underlying : source;
+		if (tFunc?.kind === "func" && sFunc?.kind === "func") {
+			if (!this._implementsMethod(tFunc, sFunc)) {
+				this.err(
+					`Cannot assign ${typeStr(source)} to ${typeStr(target)}`,
+					node,
+				);
+			}
+			return true;
+		}
+		return false;
+	},
+
 	// ── Interface satisfaction ────────────────────────────────────────
 
 	_sigParamsMatch(reqList, actList) {

package/src/typechecker/expressions.js

@@ -15,6 +15,7 @@ import {
 	isNumeric,
 	isString,
 	NIL,
+	RUNE,
 	Scope,
 	STRING,
 	TAINTED_ANY,
@@ -40,6 +41,17 @@ const BUILTIN_CHECK = {
 			s.err(`cannot append to array (type ${typeStr(st)})`, e);
 			return st;
 		}
+		const sb = s.resolveType(st?.kind === "named" ? st.underlying : st);
+		if (sb?.kind === "slice") {
+			for (let i = 1; i < e.args.length; i++) {
+				if (!e.args[i]._spread && at[i])
+					s._markIfaceBox(
+						s.resolveType(sb.elem),
+						s.resolveType(at[i]),
+						e.args[i],
+					);
+			}
+		}
 		return st;
 	},
 	copy: () => INT,
@@ -379,7 +391,7 @@ export const expressionCheckMethods = {
 	},
 
 	_rangeCollTypeTuple(resolved, collType) {
-		if (isString(resolved)) return { kind: "tuple", types: [INT, INT] };
+		if (isString(resolved)) return { kind: "tuple", types: [INT, RUNE] };
 		if (resolved?.kind === "slice" || resolved?.kind === "array")
 			return { kind: "tuple", types: [INT, resolved.elem ?? ANY] };
 		if (resolved?.kind === "map")