gofront 1.7.0 → 1.8.0

package/src/backend/wasm/emit-builtins.js

@@ -3,10 +3,16 @@
 // call expression dispatch (static, method, closure, package).
 
 import {
+	anonIfaceName,
 	getMapKeyValTypes,
 	isArrayType,
+	isBoolGoType,
+	isComplex,
+	isComplex64,
 	isMapType,
 	isNonEmptyInterface,
+	isScalarType,
+	isSigned,
 	isSliceType,
 	isStringType,
 	isStructType,
@@ -228,7 +234,12 @@ export class BuiltinsEmitter {
 			this.emitPanic("runtime error: makeslice: len out of range");
 			this.pushInstruction("end");
 
-			if (isStructType(elemGoType, this.mod.checker, this.mod)) {
+			if (
+				isStructType(elemGoType, this.mod.checker, this.mod) ||
+				isComplex(elemGoType) ||
+				(elemGoType?.kind !== "pointer" &&
+					isArrayType(elemGoType, this.mod.checker))
+			) {
 				const arrTmp = this.acquireTemp({
 					kind: "ref",
 					nullable: true,
@@ -302,6 +313,49 @@ export class BuiltinsEmitter {
 		}
 	}
 
+	_emitBuiltinNew(call) {
+		const targetType =
+			call._type?.base ??
+			(call.args[0]?.kind === "TypeExpr"
+				? call.args[0].type
+				: call.args[0]?._type) ??
+			call.args[0];
+		if (isStructType(targetType, this.mod.checker, this.mod)) {
+			let structInfo = this._resolveStructInfo({ _type: targetType });
+			if (!structInfo) {
+				const typeName =
+					targetType.kind === "named" ? targetType.name : targetType.name;
+				if (typeName) structInfo = this.mod.getStructType(typeName);
+			}
+			if (!structInfo) {
+				throw new Error(
+					`Unknown struct in new: ${targetType.name ?? targetType}`,
+				);
+			}
+			for (const f of structInfo.fields) {
+				this.emitZeroValue(f.goType, f.wType);
+			}
+			this.pushInstruction({
+				op: "struct.new",
+				typeIndex: structInfo.typeIndex,
+			});
+			return;
+		}
+		if (isArrayType(targetType, this.mod.checker)) {
+			const wType = this.toWasmType(targetType);
+			this.emitZeroValue(targetType, wType);
+			return;
+		}
+		const box = this.mod.getBoxType(targetType);
+		const valWType = this.toWasmType(targetType);
+		this.emitZeroValue(targetType, valWType);
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: box.typeIndex,
+			typeName: box.name,
+		});
+	}
+
 	// With `newLen` already computed: when it exceeds the old capacity, allocate
 	// a doubled (min 2, at least newLen) backing array and copy the old elements
 	// into it at offset 0; otherwise reuse the old array, offset and capacity.
@@ -374,6 +428,17 @@ export class BuiltinsEmitter {
 		this.pushInstruction("end");
 	}
 
+	// The source operand of `append(b, x...)` and `copy(b, x)`: a string
+	// (the only non-slice form Go allows) is converted to a fresh byte slice.
+	_emitSliceOperand(node, elemGoType, sliceWType) {
+		if (isStringType(node._type, this.mod.checker)) {
+			this.emitExpr(node, "externref");
+			this._emitStringToByteSlice({ kind: "slice", elem: elemGoType });
+			return;
+		}
+		this.emitExpr(node, sliceWType);
+	}
+
 	_emitBuiltinAppend(call) {
 		const { args } = call;
 		const sNode = args[0];
@@ -428,7 +493,7 @@ export class BuiltinsEmitter {
 
 		if (args.length === 2 && args[1]._spread) {
 			const s2Tmp = this.acquireTemp(sliceWType);
-			this.emitExpr(args[1], sliceWType);
+			this._emitSliceOperand(args[1], elemGoType, sliceWType);
 			this.pushInstruction({ op: "local.set", index: s2Tmp });
 
 			const s2ArrTmp = this.acquireTemp(arrWType);
@@ -487,7 +552,7 @@ export class BuiltinsEmitter {
 					this.pushInstruction("i32.add");
 				}
 				this.emitExpr(elemNode, arrInfo.elemWType);
-				this._emitCopyIfValueStruct(elemNode, elemGoType, arrInfo.elemWType);
+				this._emitCopyIfValue(elemNode, elemGoType, arrInfo.elemWType);
 				this.pushInstruction({
 					op: "array.set",
 					typeIndex: arrInfo.typeIndex,
@@ -538,7 +603,7 @@ export class BuiltinsEmitter {
 		this.pushInstruction({ op: "local.set", index: dstTmp });
 
 		const srcTmp = this.acquireTemp(sliceWType);
-		this.emitExpr(srcNode, sliceWType);
+		this._emitSliceOperand(srcNode, elemGoType, sliceWType);
 		this.pushInstruction({ op: "local.set", index: srcTmp });
 
 		const nTmp = this.acquireTemp("i32");
@@ -667,7 +732,7 @@ export class BuiltinsEmitter {
 			const arg = args[i];
 			const isLast = i === args.length - 1 && isPrintln;
 			const isBool =
-				arg._type?.name === "bool" ||
+				isBoolGoType(arg._type) ||
 				(arg.kind === "BasicLit" && arg.litKind === "BOOL");
 			const wType = toWasmType(arg._type, this.mod.checker);
 			this.emitExpr(arg, wType);
@@ -795,6 +860,136 @@ export class BuiltinsEmitter {
 		}
 	}
 
+	_emitBuiltinComplex(call, targetWasmType) {
+		const arg0 = call.args[0];
+		const arg1 = call.args[1];
+		const callType = call._type;
+		const is64 =
+			callType?.name === "complex64" ||
+			arg0._type?.name === "float32" ||
+			arg1._type?.name === "float32" ||
+			targetWasmType?.typeName === "$complex64";
+		const complexName = is64 ? "complex64" : "complex128";
+		const info = this.mod.getComplexType(complexName);
+		this.emitExpr(arg0, info.elemWType);
+		this.emitExpr(arg1, info.elemWType);
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		});
+	}
+
+	_emitBuiltinReal(call, targetWasmType) {
+		const arg = call.args[0];
+		const argType = arg._type ?? this._resolveExprGoType(arg);
+		const is64 = isComplex64(argType);
+		const complexName = is64 ? "complex64" : "complex128";
+		const info = this.mod.getComplexType(complexName);
+		const complexWType = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		};
+		this.emitExpr(arg, complexWType);
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		if (targetWasmType && targetWasmType !== info.elemWType) {
+			if (info.elemWType === "f32" && targetWasmType === "f64") {
+				this.pushInstruction("f64.promote_f32");
+			} else if (info.elemWType === "f64" && targetWasmType === "f32") {
+				this.pushInstruction("f32.demote_f64");
+			}
+		}
+	}
+
+	_emitBuiltinImag(call, targetWasmType) {
+		const arg = call.args[0];
+		const argType = arg._type ?? this._resolveExprGoType(arg);
+		const is64 = isComplex64(argType);
+		const complexName = is64 ? "complex64" : "complex128";
+		const info = this.mod.getComplexType(complexName);
+		const complexWType = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		};
+		this.emitExpr(arg, complexWType);
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		if (targetWasmType && targetWasmType !== info.elemWType) {
+			if (info.elemWType === "f32" && targetWasmType === "f64") {
+				this.pushInstruction("f64.promote_f32");
+			} else if (info.elemWType === "f64" && targetWasmType === "f32") {
+				this.pushInstruction("f32.demote_f64");
+			}
+		}
+	}
+
+	// min/max fold left over the operands: floats use f32/f64.min/max (NaN
+	// propagates, -0 < +0), integers `select` on lt/gt, strings compare via the
+	// string import.  A single operand is the result itself.
+	_emitBuiltinMinMax(call, targetWasmType) {
+		const isMin = call.func.name === "min";
+		const goType = call._type ?? this._resolveExprGoType(call.args[0]);
+		const wType =
+			goType?.kind === "untyped" && typeof targetWasmType === "string"
+				? targetWasmType
+				: toWasmType(goType, this.mod.checker);
+		const [first, ...rest] = call.args;
+		this.emitExpr(first, wType);
+		if (rest.length === 0) return;
+		const acc = this.acquireTemp(wType);
+		const next = this.acquireTemp(wType);
+		const isStr = isStringType(goType, this.mod.checker);
+		const isFloatType = wType === "f32" || wType === "f64";
+		const cmp = isMin ? "lt" : "gt";
+		for (const arg of rest) {
+			this.pushInstruction({ op: "local.set", index: acc });
+			this.emitExpr(arg, wType);
+			this.pushInstruction({ op: "local.set", index: next });
+			if (isFloatType) {
+				this.pushInstruction({ op: "local.get", index: acc });
+				this.pushInstruction({ op: "local.get", index: next });
+				this.pushInstruction(`${wType}.${isMin ? "min" : "max"}`);
+				continue;
+			}
+			if (isStr) {
+				// next < acc (min) / next > acc (max) ? next : acc
+				this.pushInstruction({ op: "local.get", index: next });
+				this.pushInstruction({ op: "local.get", index: acc });
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getStringCmpImportIndex(isMin ? "<" : ">"),
+				});
+				this.pushInstruction({ op: "if", blockType: wType });
+				this.pushInstruction({ op: "local.get", index: next });
+				this.pushInstruction("else");
+				this.pushInstruction({ op: "local.get", index: acc });
+				this.pushInstruction("end");
+				continue;
+			}
+			this.pushInstruction({ op: "local.get", index: next });
+			this.pushInstruction({ op: "local.get", index: acc });
+			this.pushInstruction({ op: "local.get", index: next });
+			this.pushInstruction({ op: "local.get", index: acc });
+			this.pushInstruction(`${wType}.${cmp}_${isSigned(goType) ? "s" : "u"}`);
+			this.pushInstruction("select");
+		}
+		this.releaseTemp(next, wType);
+		this.releaseTemp(acc, wType);
+	}
+
 	_emitBuiltinCall(call, targetWasmType) {
 		const { func } = call;
 		if (func.kind !== "Ident") return false;
@@ -808,6 +1003,9 @@ export class BuiltinsEmitter {
 			case "cap":
 				this._emitBuiltinCap(call, targetWasmType);
 				return true;
+			case "new":
+				this._emitBuiltinNew(call);
+				return true;
 			case "make":
 				this._emitBuiltinMake(call);
 				return true;
@@ -833,6 +1031,19 @@ export class BuiltinsEmitter {
 			case "recover":
 				this._emitBuiltinRecover(call, targetWasmType);
 				return true;
+			case "complex":
+				this._emitBuiltinComplex(call, targetWasmType);
+				return true;
+			case "real":
+				this._emitBuiltinReal(call, targetWasmType);
+				return true;
+			case "imag":
+				this._emitBuiltinImag(call, targetWasmType);
+				return true;
+			case "min":
+			case "max":
+				this._emitBuiltinMinMax(call, targetWasmType);
+				return true;
 			default:
 				return false;
 		}
@@ -845,6 +1056,12 @@ export class BuiltinsEmitter {
 			this.emitTestingCall(func, args);
 			return true;
 		}
+		if (
+			func.expr?.name &&
+			(this.resolveLocal(func.expr.name) ||
+				this.mod.resolveGlobal(func.expr.name))
+		)
+			return false;
 		const pkgName = func.expr?.name;
 		switch (pkgName) {
 			case "math":
@@ -903,6 +1120,14 @@ export class BuiltinsEmitter {
 					this.emitBytesNewReader(call, targetWasmType);
 					return true;
 				}
+				if (func.field === "NewBuffer") {
+					this.emitBytesNewBuffer(call, targetWasmType);
+					return true;
+				}
+				if (func.field === "NewBufferString") {
+					this.emitBytesNewBufferString(call, targetWasmType);
+					return true;
+				}
 				this.emitBytesCall(func.field, args, targetWasmType);
 				return true;
 			case "path":
@@ -961,6 +1186,9 @@ export class BuiltinsEmitter {
 				func.expr,
 				args,
 				targetWasmType,
+				recvTypeName === "simd.Mask32x4" ||
+					recvType?.underlying?.simd === "Mask32x4" ||
+					recvType?.simd === "Mask32x4",
 			);
 		}
 		if (
@@ -983,7 +1211,7 @@ export class BuiltinsEmitter {
 			return true;
 		}
 		if (isNonEmptyInterface(recvType, this.mod.checker)) {
-			const ifaceName = recvTypeName ?? "anon";
+			const ifaceName = recvTypeName ?? anonIfaceName(recvType);
 			const dispatchName = `__dispatch_${ifaceName}_${func.field}`;
 			const targetFuncIdx = this.mod.resolveFuncIndex(dispatchName);
 			if (targetFuncIdx !== null) {
@@ -994,7 +1222,7 @@ export class BuiltinsEmitter {
 					const pType = targetParamTypes[i + 1] ?? null;
 					const pGoType = paramGoTypes[i + 1] ?? null;
 					this.emitExpr(args[i], pType);
-					this._emitCopyIfValueStruct(args[i], pGoType, pType);
+					this._emitCopyIfValue(args[i], pGoType, pType);
 				}
 				this.pushInstruction({ op: "call", funcIndex: targetFuncIdx });
 				return true;
@@ -1016,14 +1244,20 @@ export class BuiltinsEmitter {
 			if (targetFuncIdx !== null) {
 				const recvWType = targetParamTypes[0] ?? null;
 				const recvGoType = this.mod.getFuncParamGoTypes(methodName)[0] ?? null;
-				this.emitExpr(func.expr, recvWType);
-				this._emitCopyIfValueStruct(func.expr, recvGoType, recvWType);
+				this.emitExpr(this._recvOperand(func, recvGoType), recvWType);
+				// `p.M()` with a value receiver reads `*p`: a nil `p` panics here.
+				if (
+					recvGoType?.kind !== "pointer" &&
+					isStructType(recvGoType, this.mod.checker, this.mod)
+				)
+					this._emitNilCheck(func.expr._type);
+				this._emitCopyIfValue(func.expr, recvGoType, recvWType);
 				const paramGoTypes = this.mod.getFuncParamGoTypes(methodName);
 				for (let i = 0; i < args.length; i++) {
 					const pType = targetParamTypes[i + 1] ?? null;
 					const pGoType = paramGoTypes[i + 1] ?? null;
 					this.emitExpr(args[i], pType);
-					this._emitCopyIfValueStruct(args[i], pGoType, pType);
+					this._emitCopyIfValue(args[i], pGoType, pType);
 				}
 				this.pushInstruction({ op: "call", funcIndex: targetFuncIdx });
 				return true;
@@ -1032,6 +1266,43 @@ export class BuiltinsEmitter {
 		return false;
 	}
 
+	// The receiver operand of a method call: `p.Get()` with a value receiver
+	// and `p *N` (a named scalar or slice) passes `*p`.
+	_recvOperand(func, recvGoType) {
+		const t = func.expr._type;
+		// A pointer receiver on `*p` gets `p` itself, so the method mutates *p.
+		if (recvGoType?.kind === "pointer") {
+			const pointer = this._structDerefPointer(func.expr);
+			if (pointer) return pointer;
+		}
+		if (
+			t?.kind === "pointer" &&
+			recvGoType?.kind !== "pointer" &&
+			(isScalarType(t.base, this.mod.checker, this.mod) ||
+				isSliceType(t.base, this.mod.checker))
+		)
+			return { kind: "UnaryExpr", op: "*", operand: func.expr, _type: t.base };
+		return this._ptrRecvOperand(func);
+	}
+
+	// `x.M()` with a pointer receiver on a named scalar value passes `&x`
+	// (the typechecker boxed `x`).
+	_ptrRecvOperand(func) {
+		const t = func.expr._type;
+		if (!func._type?._ptrRecv || t?.kind !== "named") return func.expr;
+		if (
+			!isScalarType(t, this.mod.checker, this.mod) &&
+			!isSliceType(t, this.mod.checker)
+		)
+			return func.expr;
+		return {
+			kind: "UnaryExpr",
+			op: "&",
+			operand: func.expr,
+			_type: { kind: "pointer", base: t },
+		};
+	}
+
 	_emitStdlibReceiverMethod(
 		recvTypeName,
 		field,
@@ -1067,11 +1338,28 @@ export class BuiltinsEmitter {
 			this.emitDurationMethodCall(field, expr, args, targetWasmType);
 			return true;
 		}
+		if (
+			recvTypeName === "time.Month" ||
+			recvTypeName === "time.Weekday" ||
+			recvTypeName === "time.Location"
+		) {
+			this.emitTimeAuxMethodCall(
+				recvTypeName,
+				field,
+				expr,
+				args,
+				targetWasmType,
+			);
+			return true;
+		}
 		if (recvTypeName === "io.LimitedReader") {
 			this.emitIoLimitedReaderMethodCall(field, expr, args, targetWasmType);
 			return true;
 		}
-		if (recvTypeName === "sync.Mutex" || recvTypeName === "sync.RWMutex") {
+		if (
+			(recvTypeName === "sync.Mutex" || recvTypeName === "sync.RWMutex") &&
+			field !== "RLocker"
+		) {
 			this.emitSyncMutexMethodCall(field, expr, args, targetWasmType);
 			return true;
 		}
@@ -1154,7 +1442,7 @@ export class BuiltinsEmitter {
 					const pType = paramTypes[i] ?? null;
 					const pGoType = paramGoTypes[i] ?? null;
 					this.emitExpr(arg, pType);
-					this._emitCopyIfValueStruct(arg, pGoType, pType);
+					this._emitCopyIfValue(arg, pGoType, pType);
 				}
 				this.pushInstruction({ op: "call", funcIndex: targetFuncIdx });
 				return true;
@@ -1175,6 +1463,8 @@ export class BuiltinsEmitter {
 
 		const closureTmp = this.acquireTemp(closureWType);
 		this.emitExpr(func, closureWType);
+		// Calling a nil func value panics like a nil pointer dereference.
+		this._emitNilBranch();
 		this.pushInstruction({ op: "local.set", index: closureTmp });
 
 		// Push param 0: env (anyref)
@@ -1191,7 +1481,7 @@ export class BuiltinsEmitter {
 			const pWType = closureInfo.paramWTypes[i] ?? null;
 			const pGoType = closureInfo.sig.params[i] ?? null;
 			this.emitExpr(arg, pWType);
-			this._emitCopyIfValueStruct(arg, pGoType, pWType);
+			this._emitCopyIfValue(arg, pGoType, pWType);
 		}
 
 		// Push funcref