gofront 1.8.0 → 1.9.0

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,6 +105,15 @@ export class ExprsEmitter {
 				return;
 			}
 
+			// A defined func or map type with methods is boxed to keep its identity,
+			// so interface dispatch can tell it from the plain func or map type.
+			if (this._isMethodNamedRef(goType)) {
+				const box = this.mod.getIfaceBoxType(this._resolveTestTarget(goType));
+				this._emitRawExpr(expr, box.wType);
+				this._emitBoxValue(box);
+				return;
+			}
+
 			if (
 				isSliceType(goType, this.mod.checker) ||
 				isArrayType(goType, this.mod.checker) ||
@@ -112,6 +125,8 @@ export class ExprsEmitter {
 				// An array stored in an interface is a copy.
 				if (isArrayType(goType, this.mod.checker))
 					this._emitCopyIfValue(expr, goType, refWType);
+				if (isTaggedSliceType(goType, this.mod.checker))
+					this._emitTagSlice(goType, refWType);
 				if (
 					isFuncType(goType, this.mod.checker) ||
 					isMapType(goType, this.mod.checker)
@@ -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) {
@@ -562,55 +656,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 +1342,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 +1424,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 +1513,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);
@@ -1681,7 +1738,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",
@@ -1797,6 +1854,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 +2104,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 = {
@@ -2599,6 +2657,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 +2686,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") {