gofront 1.6.0 → 1.7.0

package/src/backend/wasm/emit.js

@@ -8,8 +8,16 @@ import { BuiltinsEmitter } from "./emit-builtins.js";
 import { ExprsEmitter } from "./emit-exprs.js";
 import { MapsEmitter } from "./emit-maps.js";
 import { SharedEmitter } from "./emit-shared.js";
-import { StdlibEmitter } from "./emit-stdlib.js";
 import { StmtsEmitter } from "./emit-stmts.js";
+import {
+	BytesEmitter,
+	ExtendedPackagesEmitter,
+	IoEmitter,
+	PurePackagesEmitter,
+	SimdEmitter,
+	StdlibCoreEmitter,
+	TimeEmitter,
+} from "./stdlib/index.js";
 import {
 	isArrayType,
 	isPointerToStruct,
@@ -34,7 +42,14 @@ export class FunctionEmitter {
 			this.mod.lowerResult?.captures?.get(
 				this.rootFuncDecl._sourceDecl ?? this.rootFuncDecl,
 			) ?? null;
-		this.mutatedCaptures = this.captureAnalysis?.mutatedCaptures ?? new Set();
+		this.mutatedCaptures = new Set(this.captureAnalysis?.mutatedCaptures ?? []);
+		const lowerBoxed =
+			this.mod.lowerResult?.boxedVars?.get(
+				this.rootFuncDecl._sourceDecl ?? this.rootFuncDecl,
+			) ?? [];
+		for (const name of lowerBoxed) {
+			this.mutatedCaptures.add(name);
+		}
 
 		this.capturedNames = this.funcDecl._funcLit
 			? Array.from(
@@ -126,33 +141,7 @@ export class FunctionEmitter {
 			return;
 		}
 
-		const namedReturns = this.funcDecl.returnType?._namedReturns;
-		if (namedReturns && namedReturns.length > 0) {
-			this.namedReturnVars = [];
-			for (let i = 0; i < namedReturns.length; i++) {
-				const r = namedReturns[i];
-				const isBlank = !r.name || r.name === "_";
-				const varName = isBlank ? `__ret_blank$${i}` : r.name;
-				const wType = this.toWasmType(r.type);
-				const localIdx = this.allocLocal(varName, wType, r.type, isBlank);
-				this.namedReturnVars.push({
-					name: varName,
-					localIdx,
-					type: wType,
-					goType: r.type,
-					isBlank,
-				});
-				this.emitZeroValue(r.type, wType);
-				const localInfo = this.locals.get(varName);
-				if (localInfo?.isBoxed) {
-					this.pushInstruction({
-						op: "struct.new",
-						typeIndex: localInfo.boxInfo.typeIndex,
-					});
-				}
-				this.pushInstruction({ op: "local.set", index: localIdx });
-			}
-		}
+		this._initNamedReturns();
 
 		const needsOobBlock = this._needsOobBlock(body);
 		if (needsOobBlock) {
@@ -181,34 +170,38 @@ export class FunctionEmitter {
 		}
 	}
 
-	_emitFunctionBodyWithDefer(body) {
+	_initNamedReturns() {
 		const namedReturns = this.funcDecl.returnType?._namedReturns;
-		if (namedReturns && namedReturns.length > 0) {
-			this.namedReturnVars = [];
-			for (let i = 0; i < namedReturns.length; i++) {
-				const r = namedReturns[i];
-				const isBlank = !r.name || r.name === "_";
-				const varName = isBlank ? `__ret_blank$${i}` : r.name;
-				const wType = this.toWasmType(r.type);
-				const localIdx = this.allocLocal(varName, wType, r.type, isBlank);
-				this.namedReturnVars.push({
-					name: varName,
-					localIdx,
-					type: wType,
-					goType: r.type,
-					isBlank,
+		if (!namedReturns?.length) return false;
+		this.namedReturnVars = [];
+		for (let i = 0; i < namedReturns.length; i++) {
+			const r = namedReturns[i];
+			const isBlank = !r.name || r.name === "_";
+			const varName = isBlank ? `__ret_blank$${i}` : r.name;
+			const wType = this.toWasmType(r.type);
+			const localIdx = this.allocLocal(varName, wType, r.type, isBlank);
+			this.namedReturnVars.push({
+				name: varName,
+				localIdx,
+				type: wType,
+				goType: r.type,
+				isBlank,
+			});
+			this.emitZeroValue(r.type, wType);
+			const localInfo = this.locals.get(varName);
+			if (localInfo?.isBoxed) {
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: localInfo.boxInfo.typeIndex,
 				});
-				this.emitZeroValue(r.type, wType);
-				const localInfo = this.locals.get(varName);
-				if (localInfo?.isBoxed) {
-					this.pushInstruction({
-						op: "struct.new",
-						typeIndex: localInfo.boxInfo.typeIndex,
-					});
-				}
-				this.pushInstruction({ op: "local.set", index: localIdx });
 			}
-		} else if (this.returnTypes.length > 0) {
+			this.pushInstruction({ op: "local.set", index: localIdx });
+		}
+		return true;
+	}
+
+	_emitFunctionBodyWithDefer(body) {
+		if (!this._initNamedReturns() && this.returnTypes.length > 0) {
 			this.returnTempLocals = [];
 			for (let i = 0; i < this.returnTypes.length; i++) {
 				const wType = this.returnTypes[i];
@@ -662,36 +655,27 @@ export class FunctionEmitter {
 		return null;
 	}
 
-	_unpackClosureEnv() {
+	_buildEnvFields(capturedNames) {
 		const envFields = [];
-		for (const name of this.capturedNames) {
+		for (const name of capturedNames) {
 			const isBoxed = this.mutatedCaptures.has(name);
 			const goType = this._findCapturedVarGoType(name);
-			if (isBoxed) {
-				const boxInfo = this.mod.getBoxType(goType);
-				envFields.push({
-					name,
-					goType,
-					isBoxed: true,
-					boxInfo,
-					wType: {
-						kind: "ref",
-						nullable: true,
-						typeIndex: boxInfo.typeIndex,
-					},
-				});
-			} else {
-				const wType = this.toWasmType(goType);
-				envFields.push({
-					name,
-					goType,
-					isBoxed: false,
-					boxInfo: null,
-					wType,
-				});
-			}
+			const boxInfo = isBoxed ? this.mod.getBoxType(goType) : null;
+			envFields.push({
+				name,
+				goType,
+				isBoxed,
+				boxInfo,
+				wType: isBoxed
+					? { kind: "ref", nullable: true, typeIndex: boxInfo.typeIndex }
+					: this.toWasmType(goType),
+			});
 		}
+		return envFields;
+	}
 
+	_unpackClosureEnv() {
+		const envFields = this._buildEnvFields(this.capturedNames);
 		const envInfo = this.mod.getEnvType(envFields);
 		this.envInfo = envInfo;
 		this.envFields = envFields;
@@ -873,6 +857,21 @@ export class FunctionEmitter {
 			if (this.mod.structTypes.has(t.name))
 				return this.mod.structTypes.get(t.name);
 		}
+		if (t.kind === "struct" || t.kind === "StructType") {
+			const rawFields = [];
+			if (t.fields instanceof Map) {
+				for (const [k, v] of t.fields.entries())
+					rawFields.push({ name: k, goType: v });
+			} else if (Array.isArray(t.fields)) {
+				for (const f of t.fields) {
+					const names = f.names ?? (f.name ? [f.name] : []);
+					for (const n of names) rawFields.push({ name: n, goType: f.type });
+				}
+			}
+			if (rawFields.length > 0 && this.mod.getAnonStructType) {
+				return this.mod.getAnonStructType(rawFields);
+			}
+		}
 		return null;
 	}
 
@@ -930,6 +929,7 @@ export class FunctionEmitter {
 			return;
 		if (
 			node.kind === "CompositeLit" ||
+			node.kind === "CallExpr" ||
 			(node.kind === "UnaryExpr" && node.op === "*")
 		)
 			return;
@@ -959,6 +959,11 @@ export class FunctionEmitter {
 		if (recvType) {
 			let t = recvType;
 			while (t.kind === "pointer") t = t.base;
+			if (t.kind === "SelectorExpr") {
+				const pkg = t.expr?.name;
+				if (pkg) return `${pkg}.${t.field}`;
+			}
+			if (t.kind === "simd") return "simd.F32x4";
 			if (t.name) return t.name;
 			if (t.kind === "named") return t.name;
 			if (t.kind === "TypeName" || t.kind === "Ident") return t.name;
@@ -969,6 +974,10 @@ export class FunctionEmitter {
 				return this._getReceiverTypeName(loc.goType);
 			}
 		}
+		if (node && node.kind === "SelectorExpr") {
+			const pkg = node.expr?.name;
+			if (pkg) return `${pkg}.${node.field}`;
+		}
 		return null;
 	}
 
@@ -1082,6 +1091,18 @@ export class FunctionEmitter {
 		return defaultSize;
 	}
 
+	_getArrayElemType(t) {
+		if (!t) return null;
+		if (t.elem) return t.elem;
+		if (t.underlying?.elem) return t.underlying.elem;
+		if (t.kind === "ArrayType") return t.elem;
+		if (t.name && this.mod.checker?.types?.has(t.name)) {
+			const resolved = this.mod.checker.types.get(t.name);
+			return this._getArrayElemType(resolved);
+		}
+		return null;
+	}
+
 	emitZeroValue(goType, wType) {
 		if (wType === "i32") {
 			this.pushInstruction({ op: "i32.const", value: 0 });
@@ -1091,6 +1112,8 @@ export class FunctionEmitter {
 			this.pushInstruction({ op: "f32.const", value: 0.0 });
 		} else if (wType === "f64") {
 			this.pushInstruction({ op: "f64.const", value: 0.0 });
+		} else if (wType === "v128") {
+			this.pushInstruction({ op: "v128.const", bytes: new Array(16).fill(0) });
 		} else if (
 			typeof wType === "object" &&
 			wType !== null &&
@@ -1264,13 +1287,7 @@ export class FunctionEmitter {
 	}
 
 	resolveBranchDepthToOob() {
-		for (let i = this.controlStack.length - 1; i >= 0; i--) {
-			const ctrl = this.controlStack[i];
-			if (ctrl.role === "oob") {
-				return this.controlStack.length - 1 - i;
-			}
-		}
-		return null;
+		return this.resolveBranchDepthToRole("oob");
 	}
 
 	resolveBranchDepthToRole(targetRole) {
@@ -1360,11 +1377,25 @@ export class FunctionEmitter {
 				break;
 		}
 	}
+
+	_isPkgExpr(expr, pkgName) {
+		if (expr.expr?.kind !== "Ident") return false;
+		const name = expr.expr.name;
+		if (pkgName !== undefined && name !== pkgName) return false;
+		return !this.resolveLocal(name) && !this.mod.resolveGlobal(name);
+	}
 }
 
 function copyMethods(target, source) {
 	const descriptors = Object.getOwnPropertyDescriptors(source.prototype);
 	delete descriptors.constructor;
+	for (const key of Object.keys(descriptors)) {
+		if (key in target.prototype) {
+			throw new Error(
+				`Duplicate method "${key}" found while mixing ${source.name} into ${target.name}`,
+			);
+		}
+	}
 	Object.defineProperties(target.prototype, descriptors);
 }
 
@@ -1372,5 +1403,11 @@ copyMethods(FunctionEmitter, MapsEmitter);
 copyMethods(FunctionEmitter, StmtsEmitter);
 copyMethods(FunctionEmitter, ExprsEmitter);
 copyMethods(FunctionEmitter, BuiltinsEmitter);
-copyMethods(FunctionEmitter, StdlibEmitter);
+copyMethods(FunctionEmitter, StdlibCoreEmitter);
+copyMethods(FunctionEmitter, BytesEmitter);
+copyMethods(FunctionEmitter, PurePackagesEmitter);
+copyMethods(FunctionEmitter, IoEmitter);
+copyMethods(FunctionEmitter, TimeEmitter);
+copyMethods(FunctionEmitter, ExtendedPackagesEmitter);
 copyMethods(FunctionEmitter, SharedEmitter);
+copyMethods(FunctionEmitter, SimdEmitter);

package/src/backend/wasm/encode.js

@@ -52,20 +52,32 @@ export function encodeI64LEB(val) {
 	return bytes;
 }
 
+const _f32Arr = new Float32Array(1);
+const _f32Bytes = new Uint8Array(_f32Arr.buffer);
 export function encodeF32(val) {
-	const buf = new ArrayBuffer(4);
-	new DataView(buf).setFloat32(0, Number(val), true); // little-endian
-	return Array.from(new Uint8Array(buf));
+	_f32Arr[0] = Number(val);
+	return [_f32Bytes[0], _f32Bytes[1], _f32Bytes[2], _f32Bytes[3]];
 }
 
+const _f64Arr = new Float64Array(1);
+const _f64Bytes = new Uint8Array(_f64Arr.buffer);
 export function encodeF64(val) {
-	const buf = new ArrayBuffer(8);
-	new DataView(buf).setFloat64(0, Number(val), true); // little-endian
-	return Array.from(new Uint8Array(buf));
+	_f64Arr[0] = Number(val);
+	return [
+		_f64Bytes[0],
+		_f64Bytes[1],
+		_f64Bytes[2],
+		_f64Bytes[3],
+		_f64Bytes[4],
+		_f64Bytes[5],
+		_f64Bytes[6],
+		_f64Bytes[7],
+	];
 }
 
+const _textEncoder = new TextEncoder();
 function encodeString(str) {
-	const utf8 = new TextEncoder().encode(str);
+	const utf8 = _textEncoder.encode(str);
 	return [...encodeU32LEB(utf8.length), ...utf8];
 }
 
@@ -381,6 +393,49 @@ const GC_OPCODES = {
 	"extern.convert_any": 0x1b,
 };
 
+// 0xFD prefixed SIMD instructions (Wasm SIMD / v128)
+const SIMD_OPCODES = {
+	"v128.load": 0,
+	"v128.store": 11,
+	"v128.const": 12,
+	"i8x16.shuffle": 13,
+	"i8x16.swizzle": 14,
+	"i8x16.splat": 15,
+	"i16x8.splat": 16,
+	"i32x4.splat": 17,
+	"i64x2.splat": 18,
+	"f32x4.splat": 19,
+	"f64x2.splat": 20,
+	"i8x16.extract_lane_s": 21,
+	"i8x16.extract_lane_u": 22,
+	"i8x16.replace_lane": 23,
+	"i16x8.extract_lane_s": 24,
+	"i16x8.extract_lane_u": 25,
+	"i16x8.replace_lane": 26,
+	"i32x4.extract_lane": 27,
+	"i32x4.replace_lane": 28,
+	"i64x2.extract_lane": 29,
+	"i64x2.replace_lane": 30,
+	"f32x4.extract_lane": 31,
+	"f32x4.replace_lane": 32,
+	"v128.not": 77,
+	"v128.and": 78,
+	"v128.andnot": 79,
+	"v128.or": 80,
+	"v128.xor": 81,
+	"f32x4.abs": 224,
+	"f32x4.neg": 225,
+	"f32x4.sqrt": 227,
+	"f32x4.add": 228,
+	"f32x4.sub": 229,
+	"f32x4.mul": 230,
+	"f32x4.div": 231,
+	"f32x4.min": 232,
+	"f32x4.max": 233,
+	"f32x4.pmin": 234,
+	"f32x4.pmax": 235,
+};
+
 // Natural alignment (log2) per load/store opcode; memarg = align, offset.
 const MEM_ALIGN = {
 	"i32.load": 2,
@@ -421,6 +476,48 @@ function encodeInstruction(inst) {
 		return [0xfc, ...encodeU32LEB(SAT_TRUNC_OPCODES[op])];
 	}
 
+	// 2. Check SIMD opcodes (0xFD prefix)
+	if (SIMD_OPCODES[op] !== undefined) {
+		const subOp = SIMD_OPCODES[op];
+		const bytes = [0xfd, ...encodeU32LEB(subOp)];
+		if (op === "v128.load" || op === "v128.store") {
+			bytes.push(...encodeU32LEB(inst.align ?? 2));
+			bytes.push(...encodeU32LEB(inst.offset ?? 0));
+			return bytes;
+		}
+		if (op === "v128.const") {
+			const prefixLen = bytes.length;
+			if (inst.bytes) {
+				for (let i = 0; i < 16; i++) {
+					bytes.push(inst.bytes[i] ?? 0);
+				}
+			} else if (inst.values) {
+				const vals = inst.values.slice(0, 4);
+				for (const val of vals) {
+					bytes.push(...encodeF32(val));
+				}
+				while (bytes.length < prefixLen + 16) {
+					bytes.push(0);
+				}
+			} else {
+				for (let i = 0; i < 16; i++) bytes.push(0);
+			}
+			return bytes;
+		}
+		if (op === "i8x16.shuffle") {
+			const lanes = inst.lanes ?? inst.indices ?? [];
+			for (let i = 0; i < 16; i++) {
+				bytes.push(lanes[i] ?? 0);
+			}
+			return bytes;
+		}
+		if (op.includes("extract_lane") || op.includes("replace_lane")) {
+			bytes.push((inst.lane ?? inst.index ?? 0) & 0xff);
+			return bytes;
+		}
+		return bytes;
+	}
+
 	// 2. Check WasmGC opcodes (0xFB prefix)
 	if (GC_OPCODES[op] !== undefined) {
 		const subOp = GC_OPCODES[op];
@@ -907,31 +1004,45 @@ export function encodeModule(mod) {
 	const sectionOffsets = [];
 	const codeSec = encodeCodeSection(mod.funcs, sectionOffsets);
 
-	const allBytes = [
-		...magic,
-		...version,
-		...GOFRONT_SECTION_BYTES,
-		...typeSec,
-		...importSec,
-		...funcSec,
-		...memorySec,
-		...tagSec,
-		...globalSec,
-		...exportSec,
-		...startSec,
-		...elemSec,
+	const sections = [
+		magic,
+		version,
+		GOFRONT_SECTION_BYTES,
+		typeSec,
+		importSec,
+		funcSec,
+		memorySec,
+		tagSec,
+		globalSec,
+		exportSec,
+		startSec,
+		elemSec,
 	];
-	const codeStart = allBytes.length;
+	let totalLen = 0;
+	for (const s of sections) totalLen += s.length;
+	const codeStart = totalLen;
 	mod.codeOffsets = sectionOffsets.map((o) => codeStart + o);
-	allBytes.push(...codeSec);
+	totalLen += codeSec.length;
+	let smSec = null;
 	if (mod.sourceMappingURL) {
-		allBytes.push(
-			...encodeSection(0, [
-				...encodeString("sourceMappingURL"),
-				...encodeString(mod.sourceMappingURL),
-			]),
-		);
+		smSec = encodeSection(0, [
+			...encodeString("sourceMappingURL"),
+			...encodeString(mod.sourceMappingURL),
+		]);
+		totalLen += smSec.length;
+	}
+
+	const out = new Uint8Array(totalLen);
+	let offset = 0;
+	for (const s of sections) {
+		out.set(s, offset);
+		offset += s.length;
+	}
+	out.set(codeSec, offset);
+	offset += codeSec.length;
+	if (smSec) {
+		out.set(smSec, offset);
 	}
 
-	return new Uint8Array(allBytes);
+	return out;
 }