gofront 1.6.0 → 1.7.0

package/src/backend/wasm/const-fold.js

@@ -0,0 +1,205 @@
+// Compile-time folding of package-level constant expressions for the wasm
+// backend.  Folds literals, other already-folded constants, unary/binary
+// operators and `len("literal")` into a single BasicLit.  Anything it cannot
+// reduce returns null and the caller falls back to a runtime-initialised
+// global (see `_collectPackageConsts`).
+
+const INT = "INT";
+const FLOAT = "FLOAT";
+const STRING = "STRING";
+const BOOL = "BOOL";
+
+function fromLit(lit) {
+	switch (lit.litKind) {
+		case INT: {
+			const s = String(lit.value);
+			const clean = /^0[0-7]+$/.test(s) ? `0o${s.slice(1)}` : s;
+			return { k: INT, v: BigInt(clean) };
+		}
+		case FLOAT: {
+			const n = Number(lit.value);
+			return Number.isFinite(n) ? { k: FLOAT, v: n } : null;
+		}
+		case STRING:
+			return { k: STRING, v: String(lit.value ?? "") };
+		case BOOL:
+			return { k: BOOL, v: lit.value === "true" };
+		default:
+			return null;
+	}
+}
+
+function toLit(val) {
+	switch (val.k) {
+		case INT:
+			return { kind: "BasicLit", litKind: INT, value: val.v.toString() };
+		case FLOAT:
+			return {
+				kind: "BasicLit",
+				litKind: FLOAT,
+				value: Object.is(val.v, -0) ? "-0" : String(val.v),
+			};
+		case STRING:
+			return { kind: "BasicLit", litKind: STRING, value: val.v };
+		default:
+			return {
+				kind: "BasicLit",
+				litKind: BOOL,
+				value: val.v ? "true" : "false",
+			};
+	}
+}
+
+function asFloat(val) {
+	return val.k === INT ? Number(val.v) : val.v;
+}
+
+function foldUnary(op, x) {
+	if (op === "-" && x.k === INT) return { k: INT, v: -x.v };
+	if (op === "-" && x.k === FLOAT) return { k: FLOAT, v: -x.v };
+	if (op === "+" && (x.k === INT || x.k === FLOAT)) return x;
+	if (op === "!" && x.k === BOOL) return { k: BOOL, v: !x.v };
+	if (op === "^" && x.k === INT) return { k: INT, v: ~x.v };
+	return null;
+}
+
+function compare(op, a, b) {
+	switch (op) {
+		case "==":
+			return a === b;
+		case "!=":
+			return a !== b;
+		case "<":
+			return a < b;
+		case "<=":
+			return a <= b;
+		case ">":
+			return a > b;
+		case ">=":
+			return a >= b;
+		default:
+			return null;
+	}
+}
+
+function foldInts(op, a, b) {
+	switch (op) {
+		case "+":
+			return { k: INT, v: a + b };
+		case "-":
+			return { k: INT, v: a - b };
+		case "*":
+			return { k: INT, v: a * b };
+		case "/":
+			if (b === 0n) throw new Error("division by zero");
+			return { k: INT, v: a / b };
+		case "%":
+			if (b === 0n) throw new Error("division by zero");
+			return { k: INT, v: a % b };
+		case "&":
+			return { k: INT, v: a & b };
+		case "|":
+			return { k: INT, v: a | b };
+		case "^":
+			return { k: INT, v: a ^ b };
+		case "&^":
+			return { k: INT, v: a & ~b };
+		case "<<":
+			if (b < 0n) throw new Error("negative shift count");
+			return b > 1024n ? null : { k: INT, v: a << b };
+		case ">>":
+			if (b < 0n) throw new Error("negative shift count");
+			return b > 1024n ? null : { k: INT, v: a >> b };
+		default: {
+			const r = compare(op, a, b);
+			return r === null ? null : { k: BOOL, v: r };
+		}
+	}
+}
+
+function foldFloats(op, a, b) {
+	let v;
+	switch (op) {
+		case "+":
+			v = a + b;
+			break;
+		case "-":
+			v = a - b;
+			break;
+		case "*":
+			v = a * b;
+			break;
+		case "/":
+			if (b === 0) throw new Error("division by zero");
+			v = a / b;
+			break;
+		default: {
+			const r = compare(op, a, b);
+			return r === null ? null : { k: BOOL, v: r };
+		}
+	}
+	return Number.isFinite(v) ? { k: FLOAT, v } : null;
+}
+
+function foldBinary(op, a, b) {
+	if (a.k === BOOL && b.k === BOOL) {
+		if (op === "&&") return { k: BOOL, v: a.v && b.v };
+		if (op === "||") return { k: BOOL, v: a.v || b.v };
+		const r = op === "==" || op === "!=" ? compare(op, a.v, b.v) : null;
+		return r === null ? null : { k: BOOL, v: r };
+	}
+	if (a.k === STRING && b.k === STRING) {
+		if (op === "+") return { k: STRING, v: a.v + b.v };
+		const r = compare(op, a.v, b.v);
+		return r === null ? null : { k: BOOL, v: r };
+	}
+	if (a.k === INT && b.k === INT) return foldInts(op, a.v, b.v);
+	if (
+		(a.k === INT || a.k === FLOAT) &&
+		(b.k === INT || b.k === FLOAT) &&
+		op !== "<<" &&
+		op !== ">>"
+	) {
+		return foldFloats(op, asFloat(a), asFloat(b));
+	}
+	return null;
+}
+
+function foldExpr(expr, resolve) {
+	switch (expr?.kind) {
+		case "BasicLit":
+			return fromLit(expr);
+		case "Ident": {
+			if (expr.name === "true" || expr.name === "false")
+				return { k: BOOL, v: expr.name === "true" };
+			const lit = resolve(expr.name);
+			return lit ? fromLit(lit) : null;
+		}
+		case "UnaryExpr": {
+			const x = foldExpr(expr.operand, resolve);
+			return x ? foldUnary(expr.op, x) : null;
+		}
+		case "BinaryExpr": {
+			const a = foldExpr(expr.left, resolve);
+			const b = a ? foldExpr(expr.right, resolve) : null;
+			return a && b ? foldBinary(expr.op, a, b) : null;
+		}
+		case "CallExpr": {
+			if (expr.func?.kind !== "Ident" || expr.func.name !== "len") return null;
+			if (expr.args?.length !== 1) return null;
+			const s = foldExpr(expr.args[0], resolve);
+			if (s?.k !== STRING) return null;
+			// Gofront strings across JS and WASM runtime use UTF-16 code units (s.length).
+			return { k: INT, v: BigInt(s.v.length) };
+		}
+		default:
+			return null;
+	}
+}
+
+// Folds `expr` into a BasicLit, or returns null when it needs the runtime.
+// `resolve(name)` yields the BasicLit of an already-folded constant, if any.
+export function foldConstExpr(expr, resolve) {
+	const val = foldExpr(expr, resolve);
+	return val ? toLit(val) : null;
+}

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

@@ -65,18 +65,6 @@ export class BuiltinsEmitter {
 		return null;
 	}
 
-	_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;
-	}
-
 	_emitBuiltinLen(call, targetWasmType) {
 		const arg = call.args[0];
 		const argType = arg._type ?? this._resolveExprGoType(arg);
@@ -92,12 +80,7 @@ export class BuiltinsEmitter {
 				op: "call",
 				funcIndex: this.mod.resolveFuncIndex(mapInfo.lenFuncName),
 			});
-			if ((targetWasmType ?? "i64") === "i64") {
-				this.pushInstruction("i64.extend_i32_u");
-			}
-			return;
-		}
-		if (isSliceType(argType, this.mod.checker)) {
+		} else if (isSliceType(argType, this.mod.checker)) {
 			const elemType = this._getSliceElemType(argType);
 			const sliceInfo = this.mod.getSliceType(elemType);
 			const sliceWType = {
@@ -111,12 +94,7 @@ export class BuiltinsEmitter {
 				typeIndex: sliceInfo.typeIndex,
 				fieldIndex: 2,
 			});
-			if ((targetWasmType ?? "i64") === "i64") {
-				this.pushInstruction("i64.extend_i32_u");
-			}
-			return;
-		}
-		if (
+		} else if (
 			isArrayType(argType, this.mod.checker) ||
 			(argType?.kind === "pointer" &&
 				isArrayType(argType.base, this.mod.checker))
@@ -130,19 +108,13 @@ export class BuiltinsEmitter {
 			};
 			this.emitExpr(arg, arrWType);
 			this.pushInstruction("array.len");
-			if ((targetWasmType ?? "i64") === "i64") {
-				this.pushInstruction("i64.extend_i32_u");
-			}
-			return;
-		}
-		if (isStringType(argType, this.mod.checker)) {
+		} else if (isStringType(argType, this.mod.checker)) {
 			this.emitExpr(arg, "externref");
 			const lenIdx = this.mod.getStringLenImportIndex();
 			this.pushInstruction({ op: "call", funcIndex: lenIdx });
-			if ((targetWasmType ?? "i64") === "i64") {
-				this.pushInstruction("i64.extend_i32_u");
-			}
-			return;
+		}
+		if ((targetWasmType ?? "i64") === "i64") {
+			this.pushInstruction("i64.extend_i32_u");
 		}
 	}
 
@@ -177,12 +149,7 @@ export class BuiltinsEmitter {
 				typeIndex: sliceInfo.typeIndex,
 				fieldIndex: 3,
 			});
-			if ((targetWasmType ?? "i64") === "i64") {
-				this.pushInstruction("i64.extend_i32_u");
-			}
-			return;
-		}
-		if (
+		} else if (
 			isArrayType(argType, this.mod.checker) ||
 			(argType?.kind === "pointer" &&
 				isArrayType(argType.base, this.mod.checker))
@@ -196,10 +163,9 @@ export class BuiltinsEmitter {
 			};
 			this.emitExpr(arg, arrWType);
 			this.pushInstruction("array.len");
-			if ((targetWasmType ?? "i64") === "i64") {
-				this.pushInstruction("i64.extend_i32_u");
-			}
-			return;
+		}
+		if ((targetWasmType ?? "i64") === "i64") {
+			this.pushInstruction("i64.extend_i32_u");
 		}
 	}
 
@@ -894,12 +860,24 @@ export class BuiltinsEmitter {
 				this.emitSlicesCall(func.field, args, targetWasmType);
 				return true;
 			case "strings":
+				if (func.field === "NewReader") {
+					this.emitStringsNewReader(call, targetWasmType);
+					return true;
+				}
 				this.emitStringsCall(func.field, args, targetWasmType);
 				return true;
 			case "strconv":
 				this.emitStrconvCall(func.field, args);
 				return true;
 			case "fmt":
+				if (func.field.startsWith("Fprint")) {
+					this.emitFprintCall(func.field, call, targetWasmType);
+					return true;
+				}
+				if (func.field.startsWith("Sscan")) {
+					this.emitSscanCall(func.field, call, targetWasmType);
+					return true;
+				}
 				this.emitFmtCall(func.field, args);
 				return true;
 			case "errors":
@@ -914,12 +892,53 @@ export class BuiltinsEmitter {
 			case "shared":
 				this.emitSharedNew(func.field, args);
 				return true;
+			case "unicode":
+				this.emitUnicodeCall(func.field, args, targetWasmType);
+				return true;
+			case "rand":
+				this.emitRandCall(func.field, args, targetWasmType);
+				return true;
+			case "bytes":
+				if (func.field === "NewReader") {
+					this.emitBytesNewReader(call, targetWasmType);
+					return true;
+				}
+				this.emitBytesCall(func.field, args, targetWasmType);
+				return true;
+			case "path":
+			case "filepath":
+				this.emitPathCall(func.field, args);
+				return true;
+			case "html":
+				this.emitHtmlCall(func.field, args);
+				return true;
+			case "io":
+				this.emitIoCall(func.field, call, targetWasmType);
+				return true;
+			case "time":
+				this.emitTimeCall(func.field, call, targetWasmType);
+				return true;
+			case "binary":
+				this.emitBinaryCall(func.field, call, targetWasmType);
+				return true;
+			case "sha256":
+				this.emitSha256Call(func.field, call, targetWasmType);
+				return true;
+			case "hex":
+				this.emitHexCall(func.field, call, targetWasmType);
+				return true;
+			case "base64":
+				this.emitBase64Call(func.field, call, targetWasmType);
+				return true;
+			case "simd":
+				this.emitSimdPackageCall(func.field, args, targetWasmType);
+				return true;
 			default:
 				return false;
 		}
 	}
 
-	_emitMethodCall(call) {
+	_emitMethodCall(call, targetWasmType = null) {
 		const { func, args } = call;
 		if (func.kind !== "SelectorExpr") return false;
 
@@ -930,6 +949,39 @@ export class BuiltinsEmitter {
 			return true;
 		}
 		const recvTypeName = this._getReceiverTypeName(recvType, func.expr);
+		if (
+			recvTypeName === "simd.F32x4" ||
+			recvTypeName === "gofront/simd.F32x4" ||
+			recvType?.kind === "simd" ||
+			recvType?.underlying?.kind === "simd" ||
+			recvType?.name === "simd.F32x4"
+		) {
+			return this.emitSimdMethodCall(
+				func.field,
+				func.expr,
+				args,
+				targetWasmType,
+			);
+		}
+		if (
+			this._emitStdlibReceiverMethod(
+				recvTypeName,
+				func.field,
+				func.expr,
+				args,
+				targetWasmType,
+			)
+		) {
+			return true;
+		}
+		if (recvTypeName === "strings.Builder") {
+			this.emitBuilderMethodCall(func.field, func.expr, args);
+			return true;
+		}
+		if (recvTypeName === "strings.Replacer") {
+			this.emitReplacerMethodCall(func.field, func.expr, args);
+			return true;
+		}
 		if (isNonEmptyInterface(recvType, this.mod.checker)) {
 			const ifaceName = recvTypeName ?? "anon";
 			const dispatchName = `__dispatch_${ifaceName}_${func.field}`;
@@ -950,38 +1002,15 @@ export class BuiltinsEmitter {
 		}
 		if (recvTypeName) {
 			const methodName = `${recvTypeName}.${func.field}`;
-			let targetFuncIdx = this.mod.resolveFuncIndex(methodName);
-			let targetParamTypes = this.mod.getFuncParamTypes(methodName);
+			const targetFuncIdx = this.mod.resolveFuncIndex(methodName);
+			const targetParamTypes = this.mod.getFuncParamTypes(methodName);
 
 			// If not found directly, check embedded structs
-			if (targetFuncIdx === null) {
-				const structInfo = this.mod.getStructType(recvTypeName);
-				if (structInfo) {
-					for (const embed of structInfo.embeds) {
-						const embedMethodName = `${embed.name}.${func.field}`;
-						const subIdx = this.mod.resolveFuncIndex(embedMethodName);
-						if (subIdx !== null) {
-							targetFuncIdx = subIdx;
-							targetParamTypes = this.mod.getFuncParamTypes(embedMethodName);
-							const baseWType = this.toWasmType(recvType);
-							this.emitExpr(func.expr, baseWType);
-							this.pushInstruction({
-								op: "struct.get",
-								typeIndex: structInfo.typeIndex,
-								fieldIndex: embed.fieldIndex,
-							});
-							for (let i = 0; i < args.length; i++) {
-								const pType = targetParamTypes[i + 1] ?? null;
-								this.emitExpr(args[i], pType);
-							}
-							this.pushInstruction({
-								op: "call",
-								funcIndex: targetFuncIdx,
-							});
-							return true;
-						}
-					}
-				}
+			if (
+				targetFuncIdx === null &&
+				this._emitEmbeddedMethodCall(recvTypeName, func, args, recvType)
+			) {
+				return true;
 			}
 
 			if (targetFuncIdx !== null) {
@@ -1003,6 +1032,113 @@ export class BuiltinsEmitter {
 		return false;
 	}
 
+	_emitStdlibReceiverMethod(
+		recvTypeName,
+		field,
+		expr,
+		args,
+		targetWasmType = null,
+	) {
+		if (recvTypeName === "strings.Builder") {
+			this.emitBuilderMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		if (recvTypeName === "strings.Replacer") {
+			this.emitReplacerMethodCall(field, expr, args);
+			return true;
+		}
+		if (recvTypeName === "bytes.Buffer") {
+			this.emitBytesBufferMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		if (recvTypeName === "strings.Reader") {
+			this.emitStringsReaderMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		if (recvTypeName === "bytes.Reader") {
+			this.emitBytesReaderMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		if (recvTypeName === "time.Time") {
+			this.emitTimeMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		if (recvTypeName === "time.Duration") {
+			this.emitDurationMethodCall(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") {
+			this.emitSyncMutexMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		if (recvTypeName === "sync.Once") {
+			this.emitSyncOnceMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		if (recvTypeName === "sync.WaitGroup") {
+			this.emitSyncWaitGroupMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		if (
+			recvTypeName === "binary.LittleEndian" ||
+			recvTypeName === "binary.BigEndian" ||
+			recvTypeName === "encoding/binary.LittleEndian" ||
+			recvTypeName === "encoding/binary.BigEndian" ||
+			recvTypeName === "binary.ByteOrder" ||
+			recvTypeName === "encoding/binary.ByteOrder"
+		) {
+			this.emitBinaryOrderMethodCall(
+				recvTypeName,
+				field,
+				expr,
+				args,
+				targetWasmType,
+			);
+			return true;
+		}
+		if (
+			recvTypeName === "base64.Encoding" ||
+			recvTypeName === "encoding/base64.Encoding"
+		) {
+			this.emitBase64EncodingMethodCall(field, expr, args, targetWasmType);
+			return true;
+		}
+		return false;
+	}
+
+	_emitEmbeddedMethodCall(recvTypeName, func, args, recvType) {
+		const structInfo = this.mod.getStructType(recvTypeName);
+		if (!structInfo) return false;
+		for (const embed of structInfo.embeds) {
+			const embedMethodName = `${embed.name}.${func.field}`;
+			const subIdx = this.mod.resolveFuncIndex(embedMethodName);
+			if (subIdx !== null) {
+				const targetParamTypes = this.mod.getFuncParamTypes(embedMethodName);
+				const baseWType = this.toWasmType(recvType);
+				this.emitExpr(func.expr, baseWType);
+				this.pushInstruction({
+					op: "struct.get",
+					typeIndex: structInfo.typeIndex,
+					fieldIndex: embed.fieldIndex,
+				});
+				for (let i = 0; i < args.length; i++) {
+					const pType = targetParamTypes[i + 1] ?? null;
+					this.emitExpr(args[i], pType);
+				}
+				this.pushInstruction({
+					op: "call",
+					funcIndex: subIdx,
+				});
+				return true;
+			}
+		}
+		return false;
+	}
+
 	_emitStaticCall(call) {
 		const { func, args } = call;
 		if (func.kind !== "Ident") return false;
@@ -1076,6 +1212,14 @@ export class BuiltinsEmitter {
 	}
 
 	emitCallExpr(call, targetWasmType = null) {
+		if (call._isTypeConversion) {
+			this.emitTypeConversion({
+				targetType: call._conversionTargetType,
+				expr: call.args[0],
+			});
+			return;
+		}
+
 		const deqFunc = this._dequalify(call.func);
 		if (deqFunc) {
 			this.emitCallExpr({ ...call, func: deqFunc }, targetWasmType);
@@ -1090,7 +1234,7 @@ export class BuiltinsEmitter {
 			return;
 		}
 
-		if (this._emitMethodCall(call)) {
+		if (this._emitMethodCall(call, targetWasmType)) {
 			return;
 		}