gofront 1.8.0 → 1.9.1

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

@@ -11,7 +11,10 @@ import {
 	compositeLitIndices,
 	compositeLitMaxIndex,
 } from "../../typechecker/types.js";
+import { goTypeName } from "../shared/fmt-types.js";
+import { emitWasmNative } from "./natives.js";
 import {
+	getInterfaceMethodList,
 	getMapKeyValTypes,
 	isAnyType,
 	isArrayType,
@@ -19,6 +22,7 @@ import {
 	isComplex64,
 	isFuncType,
 	isMapType,
+	isNonEmptyInterface,
 	isPointerToStruct,
 	isRuneSlice,
 	isScalarType,
@@ -26,7 +30,7 @@ import {
 	isSliceType,
 	isStringType,
 	isStructType,
-	isTestingT,
+	isTaggedSliceType,
 	toWasmType,
 } from "./types.js";
 
@@ -101,27 +105,38 @@ export class ExprsEmitter {
 				return;
 			}
 
+			// A defined func type, and every array and map type, is boxed to keep
+			// its identity: arrays and maps share one wasm type across Go types
+			// (`[2]int` and `[2]int64`), and a defined func type has methods that
+			// interface dispatch must tell from the plain func type.
+			if (this._isMethodNamedRef(goType)) {
+				const box = this.mod.getIfaceBoxType(this._resolveTestTarget(goType));
+				this._emitRawExpr(expr, box.wType);
+				// An array stored in an interface is a copy.
+				if (isArrayType(box.goType, this.mod.checker))
+					this._emitCopyIfValue(expr, goType, box.wType);
+				this._emitBoxValue(box);
+				return;
+			}
+
 			if (
 				isSliceType(goType, this.mod.checker) ||
-				isArrayType(goType, this.mod.checker) ||
-				isFuncType(goType, this.mod.checker) ||
-				isMapType(goType, this.mod.checker)
+				isFuncType(goType, this.mod.checker)
 			) {
 				const refWType = this.toWasmType(goType);
 				this._emitRawExpr(expr, refWType);
-				// An array stored in an interface is a copy.
-				if (isArrayType(goType, this.mod.checker))
-					this._emitCopyIfValue(expr, goType, refWType);
-				if (
-					isFuncType(goType, this.mod.checker) ||
-					isMapType(goType, this.mod.checker)
-				)
+				if (isTaggedSliceType(goType, this.mod.checker))
+					this._emitTagSlice(goType, refWType);
+				if (isFuncType(goType, this.mod.checker))
 					this._emitNilAwareAny(goType, expr);
 				return;
 			}
 
 			// Scalar type -> box into struct
-			const scalarType = goType ?? { kind: "basic", name: "int" };
+			// An untyped rune constant boxes as `rune` (int32), like Go.
+			const scalarType = goType?.rune
+				? { kind: "basic", name: "int32" }
+				: (goType ?? { kind: "basic", name: "int" });
 			const box = this.mod.getIfaceBoxType(scalarType);
 			this._emitRawExpr(expr, box.wType);
 			this._emitBoxValue(box);
@@ -131,6 +146,85 @@ export class ExprsEmitter {
 		this._emitRawExpr(expr, targetWasmType);
 	}
 
+	// Panics with Go's failed type assertion message: the static interface
+	// type, the dynamic type of the value in `anyTmp` and the target type.
+	_emitTypeAssertPanic(expr, anyTmp) {
+		const checker = this.mod.checker;
+		const target = this._resolveTestTarget(expr._type ?? expr.type);
+		const iface = isNonEmptyInterface(target, checker);
+		this.pushInstruction({ op: "local.get", index: anyTmp });
+		if (iface) {
+			const names = getInterfaceMethodList(target.underlying ?? target)
+				.map((m) => m.name)
+				.sort();
+			this._pushStringConst(names[0] ?? "");
+		} else {
+			this._pushStringConst(this._assertSrcName(expr.expr?._type));
+		}
+		this._pushStringConst(
+			target.name === "error" ? "error" : goTypeName(target),
+		);
+		this.pushInstruction({ op: "i32.const", value: iface ? 1 : 0 });
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.resolveFuncIndex("__ta_fail"),
+		});
+		this.pushInstruction("unreachable");
+	}
+
+	// The static interface type of an assertion operand as Go names it.
+	_assertSrcName(srcType) {
+		if (!srcType || !isNonEmptyInterface(srcType, this.mod.checker))
+			return "interface {}";
+		return srcType.name === "error" ? "error" : goTypeName(srcType);
+	}
+
+	// Pushes the interned string `text` as an externref.
+	_pushStringConst(text) {
+		this.pushInstruction({
+			op: "i32.const",
+			value: this.mod.internString(text),
+		});
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.getStringImportIndex(),
+		});
+	}
+
+	// The slice on the stack becomes the tagged subtype of its Go type, so a
+	// type test can tell `[]byte` from `[]bool` (see getTaggedSliceType).  The
+	// copy shares the backing array; slice headers are immutable.
+	_emitTagSlice(goType, refWType) {
+		const tagged = this.mod.getTaggedSliceType(
+			goType,
+			this._getSliceElemType(goType),
+		);
+		const base = tagged.base;
+		const tmp = this.acquireTemp(refWType);
+		this.pushInstruction({ op: "local.tee", index: tmp });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({
+			op: "if",
+			blockType: { kind: "ref", nullable: true, typeIndex: base.typeIndex },
+		});
+		this.pushInstruction({ op: "global.get", index: base.emptyGlobalIndex });
+		this.pushInstruction("else");
+		this.pushInstruction({ op: "local.get", index: tmp });
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.set", index: tmp });
+		for (let i = 0; i < 4; i++) {
+			this.pushInstruction({ op: "local.get", index: tmp });
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: base.typeIndex,
+				fieldIndex: i,
+			});
+		}
+		this.pushInstruction({ op: "ref.null", heapType: tagged.tagTypeIndex });
+		this.pushInstruction({ op: "struct.new", typeIndex: tagged.typeIndex });
+		this.releaseTemp(tmp, refWType);
+	}
+
 	// The nullable ref on the stack becomes an interface value: a nil map, func
 	// or pointer turns into the marker of its type (never a nil interface).
 	_emitNilAwareAny(goType, expr) {
@@ -240,7 +334,8 @@ export class ExprsEmitter {
 				break;
 
 			case "CallExpr":
-				this.emitCallExpr(expr, targetWasmType);
+				if (!emitWasmNative(this, expr, targetWasmType))
+					this.emitCallExpr(expr, targetWasmType);
 				break;
 
 			case "TypeConversion":
@@ -254,7 +349,6 @@ export class ExprsEmitter {
 			case "SelectorExpr": {
 				const deq = this._dequalify(expr);
 				if (deq) this.emitIdent(deq, targetWasmType);
-				else if (this._emitPkgConst(expr, targetWasmType)) break;
 				else this.emitSelectorExpr(expr);
 				break;
 			}
@@ -286,7 +380,7 @@ export class ExprsEmitter {
 				this._emitTypeTest(targetGoType);
 				this.pushInstruction("i32.eqz");
 				this.pushInstruction({ op: "if", blockType: "void" });
-				this.emitPanic("interface conversion: type assertion failed");
+				this._emitTypeAssertPanic(expr, anyTmp);
 				this.pushInstruction("end");
 
 				this.pushInstruction({ op: "local.get", index: anyTmp });
@@ -316,7 +410,7 @@ export class ExprsEmitter {
 		if (capturedNames.length === 0) {
 			this.pushInstruction({ op: "ref.null", heapType: "any" });
 		} else {
-			const envFields = this._buildEnvFields(capturedNames);
+			const envFields = this._buildEnvFields(capturedNames, funcLit);
 			const envInfo = this.mod.getEnvType(envFields);
 
 			for (const field of envFields) {
@@ -327,6 +421,10 @@ export class ExprsEmitter {
 					);
 				}
 				this.pushInstruction({ op: "local.get", index: local.index });
+				// A non-escaping `range n` index lives in an i32 local, but a
+				// closure (such as a range-over-func body) sees a Go `int`.
+				if (!field.isBoxed && local.type === "i32" && field.wType === "i64")
+					this.pushInstruction("i64.extend_i32_s");
 			}
 
 			this.pushInstruction({
@@ -562,55 +660,7 @@ export class ExprsEmitter {
 		return this._derefStructInfo(operand) ? operand : null;
 	}
 
-	_emitPkgConst(expr, targetWasmType) {
-		if (this._isMathConst(expr)) {
-			this.emitMathConst(expr.field, targetWasmType);
-			return true;
-		}
-		if (this._isUtf8Const(expr)) {
-			this.emitUtf8Const(expr.field, targetWasmType);
-			return true;
-		}
-		if (this._isStrconvConst(expr)) {
-			this.emitStrconvConst(expr.field, targetWasmType);
-			return true;
-		}
-		if (this._isPathConst(expr)) {
-			this.emitPathConst(expr.field, targetWasmType);
-			return true;
-		}
-		if (this._isIoConst(expr)) {
-			this.emitIoConst(expr.field, targetWasmType);
-			return true;
-		}
-		if (this._isOsConst?.(expr)) {
-			this.emitOsConst(expr.field, targetWasmType);
-			return true;
-		}
-		if (this._isTimeConst(expr)) {
-			this.emitTimeConst(expr.field, targetWasmType);
-			return true;
-		}
-		if (this._isBitsConst?.(expr)) {
-			this.emitBitsConst(expr.field, targetWasmType);
-			return true;
-		}
-		if (this._isExtendedPkgConst?.(expr)) {
-			this.emitExtendedPkgConst(expr, targetWasmType);
-			return true;
-		}
-		return false;
-	}
-
 	emitSelectorExpr(expr) {
-		if (isTestingT(expr.expr?._type) && expr.field === "N") {
-			this.emitExpr(expr.expr, "externref");
-			this.pushInstruction({
-				op: "call",
-				funcIndex: this.mod.getStdlibImportIndex("testing_n"),
-			});
-			return;
-		}
 		const structInfo = this._resolveStructInfo(expr.expr);
 		if (!structInfo) {
 			if (expr.expr?.kind === "Ident" && expr.expr._type?.kind === "namespace")
@@ -1296,12 +1346,14 @@ export class ExprsEmitter {
 			constIdx < arrayLen
 		) {
 			this.emitExpr(baseNode, arrWType);
+			this._emitNilCheck(rawBaseType);
 			this.pushInstruction({ op: "i32.const", value: constIdx });
 			return;
 		}
 
 		const arrTmp = this.acquireTemp(arrWType);
 		this.emitExpr(baseNode, arrWType);
+		this._emitNilCheck(rawBaseType);
 		this.pushInstruction({ op: "local.tee", index: arrTmp });
 		this._emitCheckedIndex(indexNode, () => {
 			this.pushInstruction({ op: "local.get", index: arrTmp });
@@ -1376,6 +1428,15 @@ export class ExprsEmitter {
 		return null;
 	}
 
+	// True when the target wasm type is the `$complex64` struct, whether it is
+	// named or only carries the struct's type index.
+	_isComplex64Target(w) {
+		return (
+			w?.typeName === "$complex64" ||
+			this._complexKindOfWType(w) === "complex64"
+		);
+	}
+
 	emitBasicLit(lit, targetWasmType) {
 		const targetComplex = this._complexKindOfWType(targetWasmType);
 		const isTargetComplex64 =
@@ -1456,7 +1517,7 @@ export class ExprsEmitter {
 	emitImagLit(lit, targetWasmType) {
 		const is64 =
 			lit._type?.name === "complex64" ||
-			targetWasmType?.typeName === "$complex64";
+			this._isComplex64Target(targetWasmType);
 		const complexName = is64 ? "complex64" : "complex128";
 		const info = this.mod.getComplexType(complexName);
 		const imVal = Number(lit.value);
@@ -1518,6 +1579,13 @@ export class ExprsEmitter {
 			this._emitNilValue(ident._type, targetWasmType);
 			return;
 		}
+		// A named untyped complex constant that takes type complex64 is built
+		// from its initializer, like a complex literal, not read from its
+		// complex128 global.
+		if (ident._complexInit && this._isComplex64Target(targetWasmType)) {
+			this.emitExpr(ident._complexInit, targetWasmType);
+			return;
+		}
 
 		const localInfo = this.resolveLocal(ident.name);
 		if (localInfo) {
@@ -1589,10 +1657,17 @@ export class ExprsEmitter {
 		throw new Error(`Unresolved identifier: ${ident.name}`);
 	}
 
+	// Unary arithmetic on a complex value; `&c` and `*p` of one only move
+	// its pointer.
+	_isComplexArith(expr, op, operand) {
+		if (op === "&" || op === "*") return false;
+		return isComplex(expr._type) || isComplex(operand._type);
+	}
+
 	emitUnaryExpr(expr, targetWasmType = null) {
 		const { op, operand } = expr;
 
-		if (isComplex(expr._type) || isComplex(operand._type)) {
+		if (this._isComplexArith(expr, op, operand)) {
 			this._emitComplexUnary(expr, op, operand, targetWasmType);
 			return;
 		}
@@ -1681,7 +1756,7 @@ export class ExprsEmitter {
 			const is64 =
 				isComplex64(expr._type) ||
 				isComplex64(operand._type) ||
-				targetWasmType?.typeName === "$complex64";
+				this._isComplex64Target(targetWasmType);
 			const info = this.mod.getComplexType(is64 ? "complex64" : "complex128");
 			const cWType = {
 				kind: "ref",
@@ -1713,19 +1788,25 @@ export class ExprsEmitter {
 		}
 	}
 
+	// True when a pointer to a `t` variable is the value's own reference (an
+	// array or struct) rather than a box around it (scalars and complex).
+	_isOwnPointerValue(t) {
+		if (this._isValueArray(t)) return true;
+		return (
+			t?.kind !== "pointer" &&
+			!isComplex(t) &&
+			isStructType(t, this.mod.checker, this.mod) &&
+			!isPointerToStruct(t, this.mod.checker, this.mod)
+		);
+	}
+
 	_emitAddressOf(operand) {
 		if (operand.kind === "Ident") {
 			const loc = this.resolveLocal(operand.name);
 			if (loc?.isBoxed) {
 				this.pushInstruction({ op: "local.get", index: loc.index });
 				// A pointer to an array or struct is its reference itself.
-				const t = loc.goType;
-				if (
-					this._isValueArray(t) ||
-					(t?.kind !== "pointer" &&
-						isStructType(t, this.mod.checker, this.mod) &&
-						!isPointerToStruct(t, this.mod.checker, this.mod))
-				)
+				if (this._isOwnPointerValue(loc.goType))
 					this.pushInstruction({
 						op: "struct.get",
 						typeIndex: loc.boxInfo.typeIndex,
@@ -1774,7 +1855,8 @@ export class ExprsEmitter {
 	// The struct a `*operand` reads or writes, or null when the operand points
 	// at something else: `*pp` with `pp **T` loads a pointer, not a struct.
 	_derefStructInfo(operand) {
-		if (this._isPointerGoType(this._ptrBaseType(operand._type))) return null;
+		const base = this._ptrBaseType(operand._type);
+		if (this._isPointerGoType(base) || isComplex(base)) return null;
 		return this._resolveStructInfo(operand);
 	}
 
@@ -1797,6 +1879,7 @@ export class ExprsEmitter {
 		if (!isScalarType(baseGoType, this.mod.checker, this.mod)) {
 			const baseWType = this.toWasmType(baseGoType);
 			this.emitExpr(operand, baseWType);
+			this._emitNilCheck(operandGoType);
 			return;
 		}
 		const box = this.mod.getBoxType(baseGoType);
@@ -2046,7 +2129,7 @@ export class ExprsEmitter {
 			isComplex64(expr._type) ||
 			isComplex64(left._type) ||
 			isComplex64(right._type) ||
-			targetWasmType?.typeName === "$complex64";
+			this._isComplex64Target(targetWasmType);
 		const info = this.mod.getComplexType(is64 ? "complex64" : "complex128");
 		const f = info.elemWType;
 		const cWType = {
@@ -2433,10 +2516,26 @@ export class ExprsEmitter {
 		this.releaseTemp(bTmp, arrWType);
 	}
 
+	// Equality of two complex values on the stack -> i32.
+	_emitComplexElemEq(goType, wType) {
+		const info = this.mod.getComplexType(
+			isComplex64(goType) ? "complex64" : "complex128",
+		);
+		const bTmp = this.acquireTemp(wType);
+		const aTmp = this.acquireTemp(wType);
+		this.pushInstruction({ op: "local.set", index: bTmp });
+		this.pushInstruction({ op: "local.set", index: aTmp });
+		this._emitComplexEq(aTmp, bTmp, info, info.elemWType, "==");
+		this.releaseTemp(aTmp, wType);
+		this.releaseTemp(bTmp, wType);
+	}
+
 	// Equality of two array elements on the stack -> i32.
 	_emitElemEq(goType, wType) {
 		if (this._isValueArray(goType)) {
 			this._emitArrayEq(goType);
+		} else if (isComplex(goType)) {
+			this._emitComplexElemEq(goType, wType);
 		} else if (
 			isStructType(goType, this.mod.checker, this.mod) &&
 			!isPointerToStruct(goType, this.mod.checker, this.mod)
@@ -2599,6 +2698,8 @@ export class ExprsEmitter {
 	emitNarrowIntWrap(goType) {
 		if (!goType) return;
 		if (goType.kind === "TypeName" || goType.kind === "Ident") {
+			const declared = this.mod.checker?.types?.get(goType.name);
+			if (declared?.kind === "named") return this.emitNarrowIntWrap(declared);
 			return this.emitNarrowIntWrap({ kind: "basic", name: goType.name });
 		}
 		if (goType.kind === "named" && goType.underlying) {
@@ -2626,7 +2727,14 @@ export class ExprsEmitter {
 	}
 
 	emitDivRem(op, left, right, targetWasmType = null) {
-		const goType = left._type;
+		// An untyped constant left operand takes the type of the typed right
+		// one (`(1<<31) % uint32(n)` divides unsigned).
+		const goType =
+			left._type?.kind === "untyped" &&
+			right._type &&
+			right._type.kind !== "untyped"
+				? right._type
+				: left._type;
 		const wType = targetWasmType ?? toWasmType(goType, this.mod.checker);
 
 		if (wType === "f32" || wType === "f64") {