gofront 1.8.0 → 1.9.1

package/src/backend/wasm/emit.js

@@ -55,6 +55,18 @@ function sameSignature(c, params, paramTypes, want, got) {
 	return want === undefined || got === undefined || sameTypes(got, want);
 }
 
+// True when a struct type embeds a pointer, directly or through an embedded
+// struct: promoted method calls read through it.
+function _embedsPointer(t, seen = new Set()) {
+	const base = t?.kind === "pointer" ? t.base : t;
+	const st = base?.underlying ?? base;
+	if (!st || seen.has(st)) return false;
+	seen.add(st);
+	return (st._embeds ?? []).some(
+		(e) => e.kind === "pointer" || _embedsPointer(e, seen),
+	);
+}
+
 export class FunctionEmitter {
 	constructor(moduleEmitter, funcDecl, funcIndex) {
 		this.mod = moduleEmitter;
@@ -201,6 +213,35 @@ export class FunctionEmitter {
 		return targets;
 	}
 
+	// Outer stacked labels (`a: b: for`) alias the innermost one. Collected
+	// once per root function so the yield closures of a range-over-func loop
+	// (emitted by their own emitter) resolve them too.
+	_stackedLabelAlias(label) {
+		const root = this.rootFuncDecl;
+		if (root && !root._labelAliases) {
+			const aliases = new Map();
+			const scan = (node) => {
+				if (!node || typeof node !== "object") return;
+				if (Array.isArray(node)) {
+					for (const item of node) scan(item);
+					return;
+				}
+				if (node.kind === "LabeledStmt" && node.body?.kind === "LabeledStmt") {
+					let inner = node.body;
+					while (inner.body?.kind === "LabeledStmt") inner = inner.body;
+					aliases.set(node.label, inner.label);
+				}
+				for (const k of Object.keys(node)) {
+					if (k.startsWith("_")) continue;
+					scan(node[k]);
+				}
+			};
+			scan(root.body);
+			root._labelAliases = aliases;
+		}
+		return root?._labelAliases?.get(label) ?? this._labelAliases?.get(label);
+	}
+
 	_findLabelTarget(label, role) {
 		for (const target of this.rootFuncDecl?._labelTargets?.values() ?? []) {
 			if (target.label === label && target.role === role) return target;
@@ -781,7 +822,22 @@ export class FunctionEmitter {
 	// A pointer dereference or a call through a func value: sites whose nil
 	// operand raises Go's panic through the `nil` block.
 	_isNilTrapSite(node) {
-		if (node.kind === "CallExpr") return this._isFuncValueCall(node);
+		if (node.kind === "CallExpr")
+			return (
+				this._isFuncValueCall(node) ||
+				(node.func?.kind === "SelectorExpr" &&
+					_embedsPointer(node.func.expr?._type))
+			);
+		// Binding a method value on an interface checks it for nil.
+		if (node.kind === "NilCheckStmt") return true;
+		// A pointer to an array: indexing, slicing and ranging with a value
+		// read the array.
+		if (
+			node.kind === "IndexExpr" ||
+			node.kind === "SliceExpr" ||
+			node.kind === "RangeExpr"
+		)
+			return node.expr?._type?.kind === "pointer";
 		const star =
 			(node.kind === "UnaryExpr" && node.op === "*") ||
 			node.kind === "StarExpr";
@@ -893,11 +949,12 @@ export class FunctionEmitter {
 		return null;
 	}
 
-	_buildEnvFields(capturedNames) {
+	_buildEnvFields(capturedNames, funcLit) {
 		const envFields = [];
+		const types = this.captureAnalysis?.captureTypes?.get(funcLit);
 		for (const name of capturedNames) {
 			const isBoxed = this.mutatedCaptures.has(name);
-			const goType = this._findCapturedVarGoType(name);
+			const goType = types?.get(name) ?? this._findCapturedVarGoType(name);
 			const boxInfo = isBoxed ? this.mod.getBoxType(goType) : null;
 			envFields.push({
 				name,
@@ -913,7 +970,10 @@ export class FunctionEmitter {
 	}
 
 	_unpackClosureEnv() {
-		const envFields = this._buildEnvFields(this.capturedNames);
+		const envFields = this._buildEnvFields(
+			this.capturedNames,
+			this.funcDecl._funcLit,
+		);
 		const envInfo = this.mod.getEnvType(envFields);
 		this.envInfo = envInfo;
 		this.envFields = envFields;
@@ -1126,7 +1186,7 @@ export class FunctionEmitter {
 			const instName = (ft?.kind === "PointerType" ? ft.base : ft)?.name;
 			const embedInfo =
 				(instName && this.mod.structTypes.get(instName)) ??
-				this.mod.structTypes.get(embed.name);
+				this.mod.structTypes.get(embed.typeName ?? embed.name);
 			if (embedInfo) {
 				const sub = this._resolveFieldPath(embedInfo, fieldName);
 				if (sub) {
@@ -1381,6 +1441,7 @@ export class FunctionEmitter {
 
 		// 2. Iterate candidates
 		for (const cand of candidates) {
+			this._emitNilPtrCandidate(cand, fn, recvLocal);
 			this.pushInstruction({ op: "block", blockType: "void" });
 			this.pushInstruction({ op: "local.get", index: recvLocal });
 			this.pushInstruction({ op: "ref.test", typeIndex: cand.testTypeIndex });
@@ -1402,31 +1463,9 @@ export class FunctionEmitter {
 					typeIndex: cand.testTypeIndex,
 					fieldIndex: 0,
 				});
-				if (cand.embedPath) {
-					for (const step of cand.embedPath) {
-						if (step.castTypeIndex) {
-							this.pushInstruction({
-								op: "ref.cast",
-								typeIndex: step.castTypeIndex,
-							});
-						}
-						this.pushInstruction({
-							op: "struct.get",
-							typeIndex: step.parentTypeIndex,
-							fieldIndex: step.fieldIndex,
-						});
-					}
-				}
+				if (cand.embedPath) this._emitEmbedPath(cand);
 			} else {
-				if (cand.embedPath) {
-					for (const step of cand.embedPath) {
-						this.pushInstruction({
-							op: "struct.get",
-							typeIndex: step.parentTypeIndex,
-							fieldIndex: step.fieldIndex,
-						});
-					}
-				}
+				if (cand.embedPath) this._emitEmbedPath(cand);
 				if (cand.needsValueDeref && cand.structInfo) {
 					this.emitCloneStruct(cand.structInfo, cand.targetRecvWType);
 				}
@@ -1437,7 +1476,10 @@ export class FunctionEmitter {
 				this.pushInstruction({ op: "local.get", index: p });
 			}
 
-			this.pushInstruction({ op: "call", funcIndex: cand.funcIndex });
+			this.pushInstruction({
+				op: "call",
+				funcIndex: cand.selfDispatch ? fn._globalFuncIndex : cand.funcIndex,
+			});
 			this.pushInstruction("return");
 			this.pushInstruction("end");
 		}
@@ -1445,6 +1487,73 @@ export class FunctionEmitter {
 		emitMiss("interface conversion: nil or unmatched type for method call");
 	}
 
+	// Walks `cand.embedPath` from the embedder on the stack to the embedded
+	// value. A step through a nil embedded pointer panics, except that the last
+	// step may be nil for a pointer-receiver method (`nilCheckLast` is unset).
+	_emitEmbedPath(cand) {
+		const steps = cand.embedPath;
+		for (const [i, step] of steps.entries()) {
+			if (step.castTypeIndex) {
+				this.pushInstruction({ op: "ref.cast", typeIndex: step.castTypeIndex });
+			}
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: step.parentTypeIndex,
+				fieldIndex: step.fieldIndex,
+			});
+			if (step.ptrWType && (i < steps.length - 1 || cand.nilCheckLast))
+				this._emitNilPanicIfNull(step.ptrWType);
+		}
+	}
+
+	// Panics with a nil dereference when the reference on the stack is null,
+	// leaving it on the stack otherwise.
+	_emitNilPanicIfNull(wType) {
+		const tmp = this.acquireTemp(wType);
+		this.pushInstruction({ op: "local.tee", index: tmp });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.emitPanic(
+			"runtime error: invalid memory address or nil pointer dereference",
+		);
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: tmp });
+		this.releaseTemp(tmp, wType);
+	}
+
+	// A typed nil `*S` inside the interface is a marker object (see
+	// getNilBoxType): a pointer-receiver method runs with a nil receiver, as in
+	// Go; a value-receiver or promoted method must read through the nil pointer.
+	// A promoted candidate tests the outer struct but carries the embedded
+	// struct's info, so it is recognised by its embed path.
+	_emitNilPtrCandidate(cand, fn, recvLocal) {
+		if (cand.isBoxedValue || !cand.structInfo) return;
+		if (!cand.embedPath && cand.testTypeIndex !== cand.structInfo.typeIndex)
+			return;
+		const nilBox = this.mod.getNilBoxType({
+			kind: "pointer",
+			base: { kind: "named", name: cand.recvTypeName },
+		});
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: recvLocal });
+		this.pushInstruction({ op: "ref.test", typeIndex: nilBox.typeIndex });
+		this.pushInstruction("i32.eqz");
+		this.pushInstruction({ op: "br_if", depth: 0 });
+		if (cand.needsValueDeref || cand.embedPath) {
+			this.emitPanic(
+				"runtime error: invalid memory address or nil pointer dereference",
+			);
+		} else {
+			this.pushInstruction({ op: "ref.null", heapType: cand.testTypeIndex });
+			for (let p = 1; p < fn.params.length; p++) {
+				this.pushInstruction({ op: "local.get", index: p });
+			}
+			this.pushInstruction({ op: "call", funcIndex: cand.funcIndex });
+			this.pushInstruction("return");
+		}
+		this.pushInstruction("end");
+	}
+
 	// A value-receiver method reached through a pointer box reads the pointee
 	// first, so a nil pointer inside the interface is a catchable panic.
 	_emitNilPtrBoxPanic(cand, recvLocal) {
@@ -1570,11 +1679,9 @@ export class FunctionEmitter {
 						size,
 					});
 				} else {
-					this.pushInstruction({ op: "i32.const", value: size });
-					this.pushInstruction({
-						op: "array.new_default",
-						typeIndex: arrInfo.typeIndex,
-					});
+					this._emitNewArray(elemType, arrInfo, () =>
+						this.pushInstruction({ op: "i32.const", value: size }),
+					);
 				}
 				return;
 			}
@@ -1616,8 +1723,24 @@ export class FunctionEmitter {
 		}
 	}
 
-	allocTemp(wasmType) {
-		return this.acquireTemp(wasmType);
+	// Pushes a new array of `arrInfo` with the length `emitLen` pushes.  Elements
+	// start at their zero value: strings are the empty string, not a null
+	// reference, so the array reads, compares and prints like Go's.
+	_emitNewArray(elemType, arrInfo, emitLen) {
+		if (
+			arrInfo.elemWType === "externref" &&
+			isStringType(elemType, this.mod.checker)
+		) {
+			this.emitZeroValue(elemType, "externref");
+			emitLen();
+			this.pushInstruction({ op: "array.new", typeIndex: arrInfo.typeIndex });
+			return;
+		}
+		emitLen();
+		this.pushInstruction({
+			op: "array.new_default",
+			typeIndex: arrInfo.typeIndex,
+		});
 	}
 
 	// Temps are keyed by a canonical string so ref-typed temps (fresh object
@@ -1796,10 +1919,25 @@ export class FunctionEmitter {
 				this.emitExprStmt(stmt);
 				break;
 
+			// Evaluates `stmt.expr` and panics (recoverably) when it is nil.
+			case "NilCheckStmt":
+				this.emitExpr(stmt.expr, "anyref");
+				this._emitNilBranch();
+				this.pushInstruction("drop");
+				break;
+
 			case "LabeledStmt":
 				if (stmt.body) {
-					if (stmt.body.kind === "ForStmt") {
+					// Stacked labels (`a: b: for`) all target the loop: outer
+					// labels alias the innermost one.
+					if (stmt.body.kind !== "LabeledStmt") {
 						stmt.body.label = stmt.label;
+						this._labelAliases?.delete(stmt.label);
+					} else {
+						let inner = stmt.body;
+						while (inner.body?.kind === "LabeledStmt") inner = inner.body;
+						this._labelAliases ??= new Map();
+						this._labelAliases.set(stmt.label, inner.label);
 					}
 					this.emitStmt(stmt.body);
 				}

package/src/backend/wasm/globals.js

@@ -5,7 +5,12 @@
 import { foldConstExpr } from "../../typechecker/const-fold.js";
 import { orderPackageInits } from "../../typechecker/init-order.js";
 import { _someNode } from "./prescan.js";
-import { isStructType, toWasmType, variadicAsSlice } from "./types.js";
+import {
+	isStringType,
+	isStructType,
+	toWasmType,
+	variadicAsSlice,
+} from "./types.js";
 
 // Package-level `const` declarations (iota is already substituted by the
 // parser).  Literals and expressions the folder can reduce become BasicLits in
@@ -99,6 +104,7 @@ function _zeroFieldConst(f, mod) {
 	const w = f.wType;
 	if (w === "i64") return [{ op: "i64.const", value: 0n }];
 	if (w === "f32" || w === "f64") return [{ op: `${w}.const`, value: 0 }];
+	if (w === "v128") return [{ op: "v128.const", bytes: new Array(16).fill(0) }];
 	if (w === "externref") return [{ op: "ref.null", heapType: "extern" }];
 	if (w === "anyref") return [{ op: "ref.null", heapType: "any" }];
 	if (typeof w !== "object" || w === null)
@@ -169,6 +175,36 @@ function _zeroArrayConst(goType, mod, depth = 0) {
 	return out;
 }
 
+// True when the zero value of `t` holds a string (a string, or a struct or
+// array containing one). A constant expression cannot build the empty string,
+// so such globals get their zero value from the start function.
+function _zeroHasString(t, mod, depth = 0) {
+	if (!t || depth > 4 || _isPointerGoType(t, mod)) return false;
+	if (isStringType(t, mod.checker)) return true;
+	const shape = _arrayShape(t, mod.checker);
+	if (shape) return _zeroHasString(shape.elem, mod, depth + 1);
+	const w = toWasmType(t, mod.checker, mod);
+	if (typeof w === "object" && typeof w?.typeIndex === "number") {
+		const info = Array.from(mod.structTypes.values()).find(
+			(x) => x.typeIndex === w.typeIndex,
+		);
+		if (info)
+			return info.fields.some((f) => _zeroHasString(f.goType, mod, depth + 1));
+	}
+	return false;
+}
+
+// Types of the names in `var a, b = f()` / `var v, ok = m[k]`: one value fills
+// every name.
+function _spreadValueTypes(spec, value) {
+	if (spec._commaOk)
+		return [
+			value._mapValueType ?? value._type,
+			{ kind: "basic", name: "bool" },
+		];
+	return value?._type?.types ?? [];
+}
+
 export function _collectPackageGlobals(progs, mod, checker) {
 	const pending = []; // non-constant initializers, run by the start function
 	const pendingConsts = []; // unfoldable consts; they run before any var
@@ -183,11 +219,12 @@ export function _collectPackageGlobals(progs, mod, checker) {
 					const name = names[i];
 					// Foldable consts live in `constCache`, not in a global.
 					if (isConst && !mod.isNonLiteralConst(name)) continue;
+					const spreadTypes =
+						values.length === 1 && names.length > 1
+							? _spreadValueTypes(spec, values[0])
+							: null;
 					const rawType =
-						spec.type ??
-						(values.length === 1 && names.length > 1
-							? values[0]?._type?.types?.[i]
-							: values[i]?._type);
+						spec.type ?? (spreadTypes ? spreadTypes[i] : values[i]?._type);
 					const wType = toWasmType(rawType, checker, mod);
 					const gIdx = mod.globals.length;
 					let needsRuntimeZero = false;
@@ -252,6 +289,9 @@ export function _collectPackageGlobals(progs, mod, checker) {
 						}
 					}
 
+					if (values.length === 0 && _zeroHasString(rawType, mod))
+						needsRuntimeZero = true;
+
 					let litNode = values?.[i];
 					let sign = 1;
 					if (
@@ -302,7 +342,7 @@ export function _collectPackageGlobals(progs, mod, checker) {
 					if (needsRuntimeZero) pending.push({ name, zeroType: rawType });
 					if (!isConst && i === 0 && values.length === 1 && names.length > 1) {
 						// `var q, r = pair()`: one call fills every name.
-						pending.push({ name, names, expr: values[0] });
+						pending.push({ name, names, expr: values[0], types: spreadTypes });
 					}
 					if (values[i] && !isConstInit && names.length === values.length) {
 						(isConst ? pendingConsts : pending).push({
@@ -355,7 +395,7 @@ export function _orderConstInits(entries) {
 // initializer in declaration order and invoking package `init()` functions;
 // registered as the module start function.
 export function _makeGlobalInitFunc(pending, initNames = []) {
-	const stmts = pending.map(({ name, names, expr, zeroType }) =>
+	const stmts = pending.map(({ name, names, expr, types, zeroType }) =>
 		zeroType
 			? { kind: "GlobalZeroInit", name, goType: zeroType }
 			: {
@@ -364,7 +404,7 @@ export function _makeGlobalInitFunc(pending, initNames = []) {
 						? names.map((n, i) => ({
 								kind: "Ident",
 								name: n,
-								_type: expr._type?.types?.[i],
+								_type: types?.[i] ?? expr._type?.types?.[i],
 							}))
 						: [{ kind: "Ident", name, _type: expr._type }],
 					op: "=",

package/src/backend/wasm/glue.js

@@ -1,14 +1,12 @@
 // src/backend/wasm/glue.js
 // Runtime imports and JS glue for executing GoFront WASM modules.
 
-import { WASM_IMPORTS_JS, WASM_STDLIB_JS } from "./boundary.js";
+import { WASM_IMPORTS_JS } from "./boundary.js";
 
 // The import table is authored once as source text (it is spliced into the
 // production bundle by the facade); evaluate that same text here so tests
 // exercise exactly what ships.  The text is a compile-time constant.
-const makeImports = new Function(
-	`${WASM_IMPORTS_JS}\n${WASM_STDLIB_JS}\nreturn __gfw_imports;`,
-)();
+const makeImports = new Function(`${WASM_IMPORTS_JS}\nreturn __gfw_imports;`)();
 
 function createWasmImports({
 	stringTable = [],