gofront 1.6.0 → 1.7.0

package/src/backend/js/expressions.js

@@ -7,6 +7,7 @@ import {
 } from "../../lower/index.js";
 import {
 	ERROR,
+	isAny,
 	isComplex,
 	isTypedArraySlice,
 	typedArrayConstructorForElem,
@@ -40,6 +41,25 @@ const STRICT_OPS = new Set([
 	">>",
 ]);
 
+const NAMED_ZERO_TABLE = {
+	"time.Time": [null, "{ _d: new Date(0), _isZero: true }"],
+	"strings.Builder": [null, '{ _buf: "" }'],
+	"bytes.Buffer": [null, "{ _buf: [] }"],
+	"strings.Replacer": [null, "{ _p: [], Replace(s) { return s; } }"],
+	"sync.Mutex": ["sync", "__sync_mutex()"],
+	"sync.RWMutex": ["sync", "__sync_rwmutex()"],
+	"sync.Once": ["sync", "__sync_once()"],
+	"sync.WaitGroup": ["sync", "__sync_waitgroup()"],
+	"binary.LittleEndian": ["binary", "__binary_le"],
+	"encoding/binary.LittleEndian": ["binary", "__binary_le"],
+	"binary.BigEndian": ["binary", "__binary_be"],
+	"encoding/binary.BigEndian": ["binary", "__binary_be"],
+	"base64.Encoding": ["base64", "__base64_std"],
+	"encoding/base64.Encoding": ["base64", "__base64_std"],
+	"simd.F32x4": [null, "Object.freeze([0, 0, 0, 0])"],
+	F32x4: [null, "Object.freeze([0, 0, 0, 0])"],
+};
+
 // Splits a generated JS lvalue at its outermost trailing access:
 // `a.b[i]` → { obj: "a.b", key: "i" }, `a.b.c` → { obj: "a.b", prop: "c" }.
 function splitLastAccess(js) {
@@ -78,18 +98,76 @@ const NS_CONSTANTS = {
 	math: {
 		Pi: "Math.PI",
 		E: "Math.E",
+		Phi: "1.618033988749895",
+		Sqrt2: "Math.SQRT2",
+		SqrtE: "1.6487212707001282",
+		SqrtPi: "1.7724538509055159",
+		SqrtPhi: "1.272019649514069",
+		Ln2: "Math.LN2",
+		Log2E: "Math.LOG2E",
+		Ln10: "Math.LN10",
+		Log10E: "Math.LOG10E",
+		MaxFloat32: "3.4028234663852886e38",
+		SmallestNonzeroFloat32: "1.401298464324817e-45",
 		MaxFloat64: "Number.MAX_VALUE",
 		SmallestNonzeroFloat64: "Number.MIN_VALUE",
 		MaxInt: "Number.MAX_SAFE_INTEGER",
 		MinInt: "Number.MIN_SAFE_INTEGER",
+		MaxInt8: "127",
+		MinInt8: "-128",
+		MaxInt16: "32767",
+		MinInt16: "-32768",
+		MaxInt32: "2147483647",
+		MinInt32: "-2147483648",
+		MaxInt64: "9223372036854775807",
+		MinInt64: "-9223372036854775808",
+		MaxUint8: "255",
+		MaxUint16: "65535",
+		MaxUint32: "4294967295",
+		MaxUint: "18446744073709551615",
+		MaxUint64: "18446744073709551615",
+	},
+	strconv: {
+		ErrSyntax: "__strconv_err_syntax",
+		ErrRange: "__strconv_err_range",
+	},
+	path: {
+		ErrBadPattern: "__path_err_bad_pattern",
+	},
+	filepath: {
+		ErrBadPattern: "__path_err_bad_pattern",
 	},
 	io: {
-		EOF: '"EOF"',
+		EOF: "__io_eof",
 		Discard:
-			"{ WriteString(s) { return s.length; }, Write(b) { return b.length; } }",
+			"{ WriteString(s) { return [s.length, null]; }, Write(b) { return [b.length, null]; } }",
+	},
+	sha256: {
+		Size: "32",
+		BlockSize: "64",
+	},
+	hex: {
+		ErrLength: '__error("encoding/hex: odd length hex string")',
+	},
+	base64: {
+		StdPadding: "61",
+		NoPadding: "-1",
+		StdEncoding: "__base64_std",
+		URLEncoding: "__base64_url",
+		RawStdEncoding: "__base64_raw_std",
+		RawURLEncoding: "__base64_raw_url",
+	},
+	binary: {
+		LittleEndian: "__binary_le",
+		BigEndian: "__binary_be",
+	},
+	rand: {
+		Reader: "__crypto_rand_reader",
 	},
 	os: { Args: "process.argv" },
 	time: {
+		Nanosecond: "1",
+		Microsecond: "1000",
 		Millisecond: "1000000",
 		Second: "1000000000",
 		Minute: "60000000000",
@@ -274,12 +352,27 @@ const EXPR_GEN_DELEGATE = {
 /** @type {ThisType<CodeGen>} */
 export const expressionGenMethods = {
 	genExpr(expr) {
-		if (expr._ifaceBox && !expr._ifaceBoxing) {
+		if (this._isNamedIfaceBox(expr)) return this._genNamedIfaceBoxExpr(expr);
+		if (expr._ifaceBox && !expr._ifaceBoxing && !this._isNamedBoxKind(expr)) {
 			expr._ifaceBoxing = true;
 			try {
 				this.useHelper("ifaceBox");
-				const fn = expr._ifaceBox === "ptr" ? "__ifp" : "__ifv";
-				return `${fn}(${this.genExpr(expr)})`;
+				const fn =
+					expr._ifaceBox === "ptr"
+						? "__ifp"
+						: expr._ifaceBox === "ptr_slice"
+							? "__ifps"
+							: expr._ifaceBox === "ptr_map"
+								? "__ifpm"
+								: expr._ifaceBox === "map"
+									? "__ifm"
+									: expr._ifaceBox === "slice"
+										? "__ifs"
+										: "__ifv";
+				const extra = expr._ifacePtrFields?.length
+					? `, ${JSON.stringify(expr._ifacePtrFields)}`
+					: "";
+				return `${fn}(${this.genExpr(expr)}${extra})`;
 			} finally {
 				expr._ifaceBoxing = false;
 			}
@@ -307,6 +400,29 @@ export const expressionGenMethods = {
 		}
 	},
 
+	_isNamedBoxKind(expr) {
+		return expr._ifaceBox === "named" || expr._ifaceBox === "named_ptr";
+	},
+
+	_isNamedIfaceBox(expr) {
+		return (
+			this._isNamedBoxKind(expr) && !expr._ifaceBoxing && !expr._noNamedBox
+		);
+	},
+
+	_genNamedIfaceBoxExpr(expr) {
+		expr._ifaceBoxing = true;
+		try {
+			return this._genNamedIfaceBox(
+				this.genExpr(expr),
+				expr._ifaceNamedType,
+				expr._ifaceBox === "named_ptr",
+			);
+		} finally {
+			expr._ifaceBoxing = false;
+		}
+	},
+
 	_isStructType(t) {
 		if (!t) return false;
 		if (t.name && this.structNames.has(t.name)) return true;
@@ -453,8 +569,13 @@ export const expressionGenMethods = {
 	_emitParamCopies(params) {
 		for (const p of params) {
 			if (p.variadic || !p.name || p.name === "_") continue;
+			if (this._boxedVars.has(p.name)) {
+				// Address-taken parameter: rebind it to a { value } box.
+				this.line(`${p.name} = { value: ${p.name} };`);
+				continue;
+			}
 			const t = this._typeFromNode(p.type);
-			if (!t || this._boxedVars.has(p.name)) continue;
+			if (!t) continue;
 			if (this._fnMutates(p.name)) {
 				this.line(`${p.name} = ${this._cloneJs(t, p.name)};`);
 				this._markOwnership(p.name, true);
@@ -500,6 +621,13 @@ export const expressionGenMethods = {
 			) {
 				return this.genExpr(expr.operand);
 			}
+			if (
+				expr.operand.kind === "SelectorExpr" ||
+				expr.operand.kind === "IndexExpr"
+			) {
+				const inner = this.genExpr(expr.operand);
+				return `{ get value() { return ${inner}; }, set value(v) { ${inner} = v; } }`;
+			}
 			// For non-boxed vars (primitives, etc.), wrap in { value: x }
 			return `{ value: ${this.genExpr(expr.operand)} }`;
 		}
@@ -525,11 +653,35 @@ export const expressionGenMethods = {
 
 	_genSelectorExpr(expr) {
 		if (expr._isMethodExpr) {
+			const namedExpr = this._namedMethodExprInfo(expr);
+			if (namedExpr) return `${namedExpr.cls}.$${expr.field}`;
 			return `((recv, ...args) => recv.${expr.field}(...args))`;
 		}
+		const namedValue = this._genNamedMethodValue(expr);
+		if (namedValue !== undefined) return namedValue;
 		if (expr.expr.kind === "Ident") {
 			const nsConst = NS_CONSTANTS[expr.expr.name]?.[expr.field];
-			if (nsConst !== undefined) return nsConst;
+			if (nsConst !== undefined) {
+				if (expr.expr.name === "strconv") {
+					this.useHelper("strconvError");
+				} else if (expr.expr.name === "path" || expr.expr.name === "filepath") {
+					if (expr.field === "ErrBadPattern") this.useHelper("pathError");
+				} else if (expr.expr.name === "io" && expr.field === "EOF") {
+					this.useHelper("ioEOF");
+				} else if (expr.expr.name === "binary") {
+					this.useHelper("binary");
+				} else if (expr.expr.name === "hex") {
+					this.useHelper("hex");
+					this.useHelper("error");
+				} else if (expr.expr.name === "base64") {
+					this.useHelper("base64");
+				} else if (expr.expr.name === "rand" && expr.field === "Reader") {
+					this.useHelper("cryptoRand");
+				} else if (expr.expr.name === "sha256") {
+					this.useHelper("sha256");
+				}
+				return nsConst;
+			}
 		}
 		const base = this.genExpr(expr.expr);
 		if (this.bundledPackages.has(base)) return expr.field;
@@ -556,6 +708,81 @@ export const expressionGenMethods = {
 		return f;
 	},
 
+	// ── Named non-struct types with methods: raw values, static dispatch ──
+
+	// Boxes a raw named value (or *T) entering an interface so dynamic dispatch works.
+	_genNamedIfaceBox(js, type, isPtr) {
+		const info = this._namedBoxInfo(type);
+		if (!info) return js;
+		return isPtr ? `new ${info.cls}$Ptr(${js})` : `new ${info.cls}(${js})`;
+	},
+
+	// Static target of `x.M` on a named non-struct type: its class and the
+	// receiver argument (the { value } box for pointer receivers).
+	_namedMethodTarget(sel) {
+		const recvType = sel.expr?._type;
+		const viaPtr = recvType?.kind === "pointer";
+		const info = this._namedBoxInfo(viaPtr ? recvType.base : recvType);
+		const method = info?.methods.get(sel.field);
+		if (!method) return null;
+		let recv;
+		if (method._ptrRecv) {
+			recv = viaPtr ? this.genExpr(sel.expr) : this._genAddressOfExpr(sel.expr);
+		} else {
+			recv = viaPtr
+				? `${this.genExpr(sel.expr)}.value`
+				: this.genExpr(sel.expr);
+		}
+		return { cls: info.cls, recv };
+	},
+
+	// `x.M` used as a value: binds the receiver now, as Go does.
+	_genNamedMethodValue(expr) {
+		if (!expr._isMethodValue || expr._callee) return undefined;
+		const target = this._namedMethodTarget(expr);
+		if (!target) return undefined;
+		return `((__r) => (...__a) => ${target.cls}.$${expr.field}(__r, ...__a))(${target.recv})`;
+	},
+
+	_genAddressOfExpr(operand) {
+		return this._genUnaryExpr({
+			kind: "UnaryExpr",
+			op: "&",
+			operand,
+			_type: { kind: "pointer", base: operand._type },
+		});
+	},
+
+	// `T.M` method expression on a named non-struct type.
+	_namedMethodExprInfo(sel) {
+		const t =
+			sel.expr?._type?.kind === "named"
+				? sel.expr._type
+				: this.checker?.types.get(sel.expr?.name);
+		const info = this._namedBoxInfo(t);
+		return info?.methods.has(sel.field) ? info : null;
+	},
+
+	_genNamedMethodCall(expr) {
+		const sel = expr.func;
+		if (sel._isMethodExpr) {
+			const info = this._namedMethodExprInfo(sel);
+			if (!info) return undefined;
+			return `${info.cls}.$${sel.field}(${this._genCallArgs(expr)})`;
+		}
+		const target = this._namedMethodTarget(sel);
+		if (!target) return undefined;
+		const args = this._genCallArgs(expr);
+		return `${target.cls}.$${sel.field}(${args ? `${target.recv}, ${args}` : target.recv})`;
+	},
+
+	_genCallArgs(expr) {
+		if (expr._multiForward) return `...${this.genExpr(expr.args[0])}`;
+		return expr.args
+			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
+			.join(", ");
+	},
+
 	_genPointerSelectorField(expr, base) {
 		if (this._isStructPointerType(expr.expr._type)) {
 			const sel = `${base}.${expr.field}`;
@@ -590,9 +817,10 @@ export const expressionGenMethods = {
 	},
 
 	_isStringExprType(exprType) {
+		const t = exprType?.kind === "named" ? exprType.underlying : exprType;
 		return (
-			(exprType?.kind === "basic" && exprType.name === "string") ||
-			(exprType?.kind === "untyped" && exprType.base === "string")
+			(t?.kind === "basic" && t.name === "string") ||
+			(t?.kind === "untyped" && t.base === "string")
 		);
 	},
 
@@ -635,22 +863,104 @@ export const expressionGenMethods = {
 		const val = hoist ? "__v" : src;
 		const check = this._typeCheckExpr(expr.type, val);
 		const wrap = (body) => (hoist ? `((__v) => ${body})(${src})` : body);
+		// Named non-struct values sit in interfaces as boxes; the asserted value is raw.
+		const out = this._isNamedBoxTypeNode(expr.type)
+			? `${val}.__gfUnbox()`
+			: val;
 		if (!expr._commaOk) {
 			// plain assertion: panic if check fails (matches Go behavior)
 			if (check === "true") return src; // can't check at runtime — pass through
 			return wrap(
-				`(${check} ? ${val} : (() => { throw new Error("interface conversion: type assertion failed"); })())`,
+				`(${check} ? ${out} : (() => { throw new Error("interface conversion: type assertion failed"); })())`,
 			);
 		}
 		// comma-ok: emit [value-or-zero, runtimeTypeCheck]
 		const zero = this.zeroValueForTypeNode(expr.type);
-		return wrap(`(${check} ? [${val}, true] : [${zero}, false])`);
+		return wrap(`(${check} ? [${out}, true] : [${zero}, false])`);
+	},
+
+	_typeNameCheckExpr(name, val) {
+		if (TYPEOF_NUMBER_NAMES.has(name)) return `typeof ${val} === "number"`;
+		if (name === "string") return `typeof ${val} === "string"`;
+		if (name === "bool") return `typeof ${val} === "boolean"`;
+		if (name === "nil") return `${val} === null`;
+		if (name === "error")
+			return `(typeof ${val} === "object" && ${val} !== null && typeof ${val}.Error === "function")`;
+		if (this.structNames.has(name))
+			return `(${val} instanceof ${name} && ${val}.__p !== true)`;
+		const named = this.checker?.types.get(name);
+		const namedInfo = this._namedBoxInfo(named);
+		if (namedInfo) return `(${val} instanceof ${namedInfo.cls})`;
+		// User-declared interfaces: check the dynamic value has every method.
+		if (!name.includes(".") && named?.underlying?.kind === "interface")
+			return this._ifaceMethodCheck(val, [...named.underlying.methods.keys()]);
+		return "true"; // unknown type — can't check at runtime
+	},
+
+	// Anonymous interfaces and pointers to named non-struct types; null otherwise.
+	_namedOrIfaceCheckExpr(typeNode, val) {
+		if (typeNode.kind === "InterfaceType" && !(typeNode.embeds?.length > 0))
+			return this._ifaceMethodCheck(
+				val,
+				(typeNode.methods ?? []).map((m) => m.name),
+			);
+		if (typeNode.kind === "PointerType" && typeNode.base?.kind === "TypeName") {
+			const info = this._namedBoxInfo(
+				this.checker?.types.get(typeNode.base.name),
+			);
+			if (info) return `(${val} instanceof ${info.cls}$Ptr)`;
+		}
+		return null;
+	},
+
+	_ifaceMethodCheck(val, methodNames) {
+		const checks = methodNames.map((m) => `typeof ${val}.${m} === "function"`);
+		return `(${[`${val} != null`, ...checks].join(" && ")})`;
+	},
+
+	_isNamedBoxTypeNode(typeNode) {
+		if (typeNode?.kind === "TypeName")
+			return Boolean(
+				this._namedBoxInfo(this.checker?.types.get(typeNode.name)),
+			);
+		if (typeNode?.kind === "PointerType" && typeNode.base?.kind === "TypeName")
+			return Boolean(
+				this._namedBoxInfo(this.checker?.types.get(typeNode.base.name)),
+			);
+		return false;
 	},
 
 	_genTypeConversionCall(expr) {
-		const name = expr._conversionTargetType?.name;
+		const targetType = expr._conversionTargetType;
 		const arg = this.genExpr(expr.args[0]);
-		if (name && this.namedWrapperNames.has(name)) return `new ${name}(${arg})`;
+		const isRaw =
+			targetType?.name === "json.RawMessage" ||
+			targetType?.name === "encoding/json.RawMessage";
+		const base =
+			targetType?.kind === "named" ? targetType.underlying : targetType;
+		if (
+			targetType?.kind === "named" &&
+			base?.kind === "basic" &&
+			this._namedBoxInfo(targetType)
+		)
+			return this._genPrimitiveConversion(
+				{ expr: expr.args[0] },
+				arg,
+				base.name,
+			);
+		if (base?.kind === "slice") {
+			const elem = base.elem?.name;
+			if (
+				(elem === "byte" || elem === "uint8") &&
+				this._isStringExprType(expr.args[0]?._type)
+			) {
+				const enc = `new TextEncoder().encode(${arg})`;
+				return isRaw ? `((u) => { u.__raw = true; return u; })(${enc})` : enc;
+			}
+			if (isRaw) {
+				return `((u) => { u.__raw = true; return u; })(${arg})`;
+			}
+		}
 		return arg;
 	},
 
@@ -705,12 +1015,93 @@ export const expressionGenMethods = {
 			return this._genRegexpMethodCall(expr.func.field, expr);
 		if (recvName === "time.Time")
 			return this._genTimeMethodCall(expr.func.field, expr);
+		if (recvName === "time.Duration")
+			return this._genDurationMethodCall(expr.func.field, expr);
 		if (recvName === "testing.T")
 			return this._genTestingMethodCall(expr.func.field, expr);
+		if (recvName === "strings.Replacer") {
+			const recv = this.genExpr(expr.func.expr);
+			const arg = this.genExpr(expr.args[0]);
+			return `(${recv} ? ${recv}.Replace(${arg}) : ${arg})`;
+		}
 		if (recvName?.startsWith("shared.") && expr.func.field === "Subarray") {
 			const args = expr.args.map((a) => this.genExpr(a)).join(", ");
 			return `${this.genExpr(expr.func.expr)}.subarray(${args})`;
 		}
+		if (recvName === "simd.F32x4" || recvName === "F32x4") {
+			return this._genSimdReceiverCall(expr);
+		}
+		if (recvName === "sync.Mutex" || recvName === "sync.RWMutex") {
+			if (expr.func.field === "TryLock" || expr.func.field === "TryRLock")
+				return "true";
+			return "(void 0)";
+		}
+		if (recvName === "sync.Once" && expr.func.field === "Do") {
+			const recv = this.genExpr(expr.func.expr);
+			const f = this.genExpr(expr.args[0]);
+			return `((o, fn) => { if (!o.done) { o.done = 1; fn(); } })(${recv}, ${f})`;
+		}
+		if (recvName === "sync.WaitGroup") {
+			const recv = this.genExpr(expr.func.expr);
+			if (expr.func.field === "Add") {
+				return `((wg, d) => { wg.counter = (wg.counter || 0) + d; })(${recv}, ${this.genExpr(expr.args[0])})`;
+			}
+			if (expr.func.field === "Done") {
+				return `((wg) => { wg.counter = (wg.counter || 0) - 1; })(${recv})`;
+			}
+			if (expr.func.field === "Wait") return "(void 0)";
+		}
+		if (
+			recvName === "binary.LittleEndian" ||
+			recvName === "binary.BigEndian" ||
+			recvName === "encoding/binary.LittleEndian" ||
+			recvName === "encoding/binary.BigEndian" ||
+			recvName === "binary.ByteOrder" ||
+			recvName === "encoding/binary.ByteOrder"
+		) {
+			this.useHelper("binary");
+			const recv = this.genExpr(expr.func.expr);
+			const args = expr.args.map((a) => this.genExpr(a)).join(", ");
+			return `${recv}.${expr.func.field}(${args})`;
+		}
+		if (
+			recvName === "base64.Encoding" ||
+			recvName === "encoding/base64.Encoding"
+		) {
+			this.useHelper("base64");
+			const recv = this.genExpr(expr.func.expr);
+			const args = expr.args.map((a) => this.genExpr(a)).join(", ");
+			return `${recv}.${expr.func.field}(${args})`;
+		}
+		return undefined;
+	},
+
+	_genSimdReceiverCall(expr) {
+		this.useHelper("simd");
+		const method = expr.func.field;
+		const recv = this.genExpr(expr.func.expr);
+		const helpers = {
+			Add: "__simd_add",
+			Sub: "__simd_sub",
+			Mul: "__simd_mul",
+			Div: "__simd_div",
+			Min: "__simd_min",
+			Max: "__simd_max",
+			Dot3: "__simd_dot3",
+			Dot4: "__simd_dot4",
+		};
+		if (helpers[method]) {
+			return `${helpers[method]}(${recv}, ${this.genExpr(expr.args[0])})`;
+		}
+		if (method === "Lane") {
+			return `${recv}[${this.genExpr(expr.args[0])}]`;
+		}
+		if (method === "WithLane") {
+			return `__simd_with_lane(${recv}, ${this.genExpr(expr.args[0])}, ${this.genExpr(expr.args[1])})`;
+		}
+		if (method === "Splat") {
+			return `__simd_splat(${this.genExpr(expr.args[0])})`;
+		}
 		return undefined;
 	},
 
@@ -731,6 +1122,8 @@ export const expressionGenMethods = {
 		const recvName = this._resolveRecvName(recvType);
 		const typed = this._genReceiverTypeCall(recvName, expr);
 		if (typed !== undefined) return typed;
+		const namedCall = this._genNamedMethodCall(expr);
+		if (namedCall !== undefined) return namedCall;
 		if (this.strict && this._isInterfaceType(recvType)) {
 			// Go panics with a nil-dereference runtime error; JS would throw a
 			// TypeError with a different message.
@@ -933,7 +1326,9 @@ export const expressionGenMethods = {
 				? this.genValueExpr(match.value ?? match)
 				: fields[idx].zero;
 		} else {
-			values[idx] = `${this.genExpr(e.value)}.${ef}`;
+			const valExpr = this.genExpr(e.value);
+			values[idx] =
+				`(${valExpr} != null ? ${valExpr}.${ef} : ${fields[idx].zero})`;
 		}
 		return idx;
 	},
@@ -951,6 +1346,11 @@ export const expressionGenMethods = {
 					const idx = this._fillEmbedField(fields, ef, e, values);
 					if (idx > maxIdx) maxIdx = idx;
 				}
+				const embedIdx = fields.findIndex((f) => f.name === k);
+				if (embedIdx >= 0) {
+					values[embedIdx] = this.genValueExpr(e.value);
+					if (embedIdx > maxIdx) maxIdx = embedIdx;
+				}
 			} else {
 				const idx = fields.findIndex((f) => f.name === k);
 				if (idx >= 0) {
@@ -974,17 +1374,53 @@ export const expressionGenMethods = {
 		const maxExplicitIdx = hasPositional
 			? this._fillPositionalStructElems(fields, expr, values)
 			: this._fillKeyedStructElems(fields, expr, values);
-		if (maxExplicitIdx < 0) {
-			return `new ${typeName}()`;
+		const inst =
+			maxExplicitIdx < 0
+				? `new ${typeName}()`
+				: `new ${typeName}(${values.slice(0, maxExplicitIdx + 1).join(", ")})`;
+		return inst;
+	},
+
+	_genSliceOrArrayLit(t, expr) {
+		const elems = expr.elems
+			.map((e) => this.genValueExpr(e.kind === "KeyValueExpr" ? e.value : e))
+			.join(", ");
+		const elemNode =
+			t.kind === "SliceType" || t.kind === "ArrayType" ? t.elem : null;
+		const elemResolved =
+			expr._type?.kind === "slice" || expr._type?.kind === "array"
+				? expr._type.elem
+				: null;
+		const typedCtor =
+			typedArrayConstructorForElem(elemResolved) ??
+			(elemNode?.name
+				? typedArrayConstructorForElem({
+						kind: "basic",
+						name: elemNode.name,
+					})
+				: null);
+		if (typedCtor) {
+			return `new ${typedCtor}([${elems}])`;
 		}
-		const args = values.slice(0, maxExplicitIdx + 1);
-		return `new ${typeName}(${args.join(", ")})`;
+		return `[${elems}]`;
 	},
 
 	genCompositeLit(expr) {
 		const t = expr.typeExpr;
 		if (t === null) return this._genImplicitCompositeLit(expr);
 		const typeName = this.getTypeName(t);
+		if (typeName === "bytes.Buffer" || typeName === "Buffer")
+			return "{ _buf: [] }";
+		if (typeName === "strings.Builder" || typeName === "Builder")
+			return '{ _buf: "" }';
+		if (typeName === "simd.F32x4" || typeName === "F32x4") {
+			this.useHelper("simd");
+			const a = expr.elems[0] ? this.genExpr(expr.elems[0]) : "0";
+			const b = expr.elems[1] ? this.genExpr(expr.elems[1]) : "0";
+			const c = expr.elems[2] ? this.genExpr(expr.elems[2]) : "0";
+			const d = expr.elems[3] ? this.genExpr(expr.elems[3]) : "0";
+			return `__simd_f32x4(${a}, ${b}, ${c}, ${d})`;
+		}
 		if (typeName && this.structNames.has(typeName))
 			return this._genPositionalStructLit(typeName, expr);
 		if (typeName && this.namedWrapperNames.has(typeName))
@@ -992,29 +1428,7 @@ export const expressionGenMethods = {
 		if (expr.elems.some((e) => e._positionalField)) {
 			if (typeName) return this._genPositionalStructLit(typeName, expr);
 		}
-		if (this._isSliceOrArrayType(t)) {
-			const elems = expr.elems
-				.map((e) => this.genValueExpr(e.kind === "KeyValueExpr" ? e.value : e))
-				.join(", ");
-			const elemNode =
-				t.kind === "SliceType" || t.kind === "ArrayType" ? t.elem : null;
-			const elemResolved =
-				expr._type?.kind === "slice" || expr._type?.kind === "array"
-					? expr._type.elem
-					: null;
-			const typedCtor =
-				typedArrayConstructorForElem(elemResolved) ??
-				(elemNode?.name
-					? typedArrayConstructorForElem({
-							kind: "basic",
-							name: elemNode.name,
-						})
-					: null);
-			if (typedCtor) {
-				return `new ${typedCtor}([${elems}])`;
-			}
-			return `[${elems}]`;
-		}
+		if (this._isSliceOrArrayType(t)) return this._genSliceOrArrayLit(t, expr);
 		if (this._isMapTypeNode(t))
 			return `{ ${this._genMapLitEntries(expr.elems)} }`;
 		return this._genFallbackCompositeLit(expr);
@@ -1049,25 +1463,13 @@ export const expressionGenMethods = {
 		const namedType = this.checker?.types.get(typeName);
 		const u = namedType?.underlying;
 		if (u?.kind === "map") {
-			const entries = expr.elems
-				.map((e) => {
-					if (e.kind === "KeyValueExpr") {
-						const k =
-							e.key.litKind === "STRING"
-								? JSON.stringify(e.key.value)
-								: `[${this.genExpr(e.key)}]`;
-						return `${k}: ${this.genValueExpr(e.value)}`;
-					}
-					return this.genValueExpr(e);
-				})
-				.join(", ");
-			return `new ${typeName}({ ${entries} })`;
+			return `{ ${this._genMapLitEntries(expr.elems)} }`;
 		}
 		// Default: slice
 		const elems = expr.elems
 			.map((e) => this.genValueExpr(e.kind === "KeyValueExpr" ? e.value : e))
 			.join(", ");
-		return `new ${typeName}([${elems}])`;
+		return `[${elems}]`;
 	},
 
 	// ── Helpers ───────────────────────────────────────────────────
@@ -1109,11 +1511,14 @@ export const expressionGenMethods = {
 	},
 
 	// Returns true if the AST node contains a function call (side-effect risk).
-	_hasCallExpr(node) {
+	_hasCallExpr(node, seen = new Set()) {
 		if (!node || typeof node !== "object") return false;
+		if (seen.has(node)) return false;
+		seen.add(node);
 		if (node.kind === "CallExpr") return true;
-		for (const v of Object.values(node)) {
-			if (v && typeof v === "object" && this._hasCallExpr(v)) return true;
+		for (const [k, v] of Object.entries(node)) {
+			if (k.startsWith("_") || k === "scope") continue;
+			if (v && typeof v === "object" && this._hasCallExpr(v, seen)) return true;
 		}
 		return false;
 	},
@@ -1124,8 +1529,20 @@ export const expressionGenMethods = {
 	},
 
 	_zeroForNamedType(name) {
-		if (name === "strings.Builder") return '{ _buf: "" }';
-		if (name === "bytes.Buffer") return "{ _buf: [] }";
+		const entry = NAMED_ZERO_TABLE[name];
+		if (entry) {
+			if (entry[0]) this.useHelper(entry[0]);
+			return entry[1];
+		}
+		const named = this.checker?.types.get(name);
+		const u = named?.kind === "named" ? named.underlying : null;
+		if (
+			u &&
+			u.kind !== "struct" &&
+			u.kind !== "interface" &&
+			u.kind !== "named"
+		)
+			return this.zeroValueForType(u);
 		name = this._dequalify(name);
 		if (this.structNames.has(name)) return `new ${name}()`;
 		return "null";
@@ -1214,18 +1631,10 @@ export const expressionGenMethods = {
 	// Emit a JS boolean expression that checks whether `val` matches type node `t`.
 	_typeCheckExpr(typeNode, val) {
 		if (!typeNode) return "true";
-		if (typeNode.kind === "TypeName") {
-			const name = typeNode.name;
-			if (TYPEOF_NUMBER_NAMES.has(name)) return `typeof ${val} === "number"`;
-			if (name === "string") return `typeof ${val} === "string"`;
-			if (name === "bool") return `typeof ${val} === "boolean"`;
-			if (name === "nil") return `${val} === null`;
-			if (name === "error")
-				return `(typeof ${val} === "object" && ${val} !== null && typeof ${val}.Error === "function")`;
-			if (this.structNames.has(name))
-				return `(${val} instanceof ${name} && ${val}.__p !== true)`;
-			return "true"; // unknown type — can't check at runtime
-		}
+		if (typeNode.kind === "TypeName")
+			return this._typeNameCheckExpr(typeNode.name, val);
+		const extended = this._namedOrIfaceCheckExpr(typeNode, val);
+		if (extended) return extended;
 		if (
 			typeNode.kind === "PointerType" &&
 			typeNode.base?.kind === "TypeName" &&
@@ -1297,6 +1706,12 @@ export const expressionGenMethods = {
 			return expr.op === "==" ? cmp : `!${cmp}`;
 		}
 
+		if (this._isIfaceEquality(expr)) {
+			this.useHelper("ifeq");
+			const cmp = `__ifeq(${this._genIfaceOperand(expr.left)}, ${this._genIfaceOperand(expr.right)})`;
+			return expr.op === "==" ? cmp : `!${cmp}`;
+		}
+
 		if (this.strict && this._needsStrictOp(expr.op, expr._type)) {
 			const l = this.genExpr(expr.left);
 			const r = this.genExpr(expr.right);
@@ -1331,6 +1746,31 @@ export const expressionGenMethods = {
 		);
 	},
 
+	_isIfaceType(t) {
+		return isAny(t) || this._isInterfaceType(t);
+	},
+
+	// Interface comparisons go through __ifeq so boxed named values compare by
+	// dynamic type and value, as in Go (`err == ErrNotFound`).
+	_isIfaceEquality(expr) {
+		if (expr.op !== "==" && expr.op !== "!=") return false;
+		if (this._isNilLiteral(expr.left) || this._isNilLiteral(expr.right))
+			return false;
+		return (
+			this._isIfaceType(expr.left._type) || this._isIfaceType(expr.right._type)
+		);
+	},
+
+	// A concrete operand compared with an interface is converted to an interface first.
+	_genIfaceOperand(e) {
+		if (e._ifaceBox || this._isIfaceType(e._type)) return this.genExpr(e);
+		const isPtr = e._type?.kind === "pointer";
+		const named = isPtr ? e._type.base : e._type;
+		if (this._namedBoxInfo(named))
+			return this._genNamedIfaceBox(this.genExpr(e), named, isPtr);
+		return this.genExpr(e);
+	},
+
 	_isIntDivision(expr) {
 		return (
 			expr.op === "/" &&
@@ -1356,6 +1796,7 @@ export const expressionGenMethods = {
 		)
 			return null;
 		if (this._isStructEquality(expr) || this._isIntDivision(expr)) return null;
+		if (this._isIfaceEquality(expr)) return null;
 		if (expr.op === "&^") return "&";
 		if (expr.op === "==" || expr.op === "!=") {
 			if (this._isNilLiteral(expr.left) || this._isNilLiteral(expr.right))
@@ -1380,8 +1821,13 @@ export const expressionGenMethods = {
 			this.useHelper("error");
 			return `__error(${inner})`;
 		}
-		if (target && this.namedWrapperNames.has(target))
-			return `new ${target}(${inner})`;
+		if (target && this.namedWrapperNames.has(target)) {
+			const named = this.checker?.types.get(target);
+			const u = named?.underlying;
+			return u?.kind === "basic"
+				? this._genPrimitiveConversion(expr, inner, u.name)
+				: inner;
+		}
 		return this._genPrimitiveConversion(expr, inner, target);
 	},
 
@@ -1397,24 +1843,19 @@ export const expressionGenMethods = {
 		return inner;
 	},
 
-	_isStringSource(srcType) {
-		return (
-			(srcType?.kind === "basic" && srcType?.name === "string") ||
-			(srcType?.kind === "untyped" && srcType?.base === "string")
-		);
-	},
-
 	_genSliceTypeConversion(expr, inner, t) {
 		const elem = t.elem?.name;
 		if (elem === "byte" || elem === "uint8") {
-			if (this._isStringSource(expr.expr._type))
+			if (this._isStringExprType(expr.expr._type))
 				return `new TextEncoder().encode(${inner})`;
+			if (isAny(expr.expr._type) || !expr.expr._type)
+				return `(typeof ${inner} === "string" ? new TextEncoder().encode(${inner}) : new Uint8Array(${inner}))`;
 			return `new Uint8Array(${inner})`;
 		}
 		const typedCtor = typedArrayConstructorForElem(
 			t.elem ? { kind: "basic", name: t.elem.name } : null,
 		);
-		const fromString = this._isStringSource(expr.expr._type);
+		const fromString = this._isStringExprType(expr.expr._type);
 		if (typedCtor) {
 			return fromString
 				? `${typedCtor}.from(${inner}, __c => __c.codePointAt(0))`
@@ -1426,10 +1867,10 @@ export const expressionGenMethods = {
 	},
 
 	_genStringConversion(srcType, inner) {
-		if (srcType && this.isIntType(srcType))
-			return `String.fromCodePoint(${inner})`;
-		if (srcType?.kind === "slice") {
-			const elem = srcType.elem?.name;
+		const base = srcType?.kind === "named" ? srcType.underlying : srcType;
+		if (base && this.isIntType(base)) return `String.fromCodePoint(${inner})`;
+		if (base?.kind === "slice") {
+			const elem = base.elem?.name;
 			if (elem === "byte" || elem === "uint8")
 				return `new TextDecoder().decode(new Uint8Array(${inner}))`;
 			if (elem === "rune" || elem === "int" || elem === "int32")
@@ -1532,81 +1973,55 @@ export const expressionGenMethods = {
 		if (tName === "float32") {
 			return `Math.fround(${l} ${op} ${r})`;
 		}
-		if (tName === "int32" || tName === "rune") {
-			if (op === "*") return `Math.imul(${l}, ${r})`;
-			if (op === "/")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (Math.trunc((${l}) / (${r})) | 0))`;
-			if (op === "%")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((${l}) % (${r})) | 0))`;
-			if (op === "<<" || op === ">>") {
-				return `((${r}) >= 32 ? (${op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0"}) : ((${l}) ${op} (${r}))) | 0`;
-			}
-			if (op === "&^") return `((${l}) & ~(${r})) | 0`;
-			return `((${l} ${op} ${r}) | 0)`;
-		}
-		if (tName === "uint32") {
-			if (op === "/")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (Math.trunc((${l}) / (${r})) >>> 0))`;
-			if (op === "%")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((${l}) % (${r})) >>> 0))`;
-			if (op === "<<" || op === ">>") {
-				const jsOp = op === ">>" ? ">>>" : "<<";
-				return `((${r}) >= 32 ? 0 : ((${l}) ${jsOp} (${r}))) >>> 0`;
-			}
-			if (op === "&^") return `((${l}) & ~(${r})) >>> 0`;
-			return `((${l} ${op} ${r}) >>> 0)`;
-		}
-		if (tName === "int8") {
-			if (op === "/")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : ((Math.trunc((${l}) / (${r})) << 24) >> 24))`;
-			if (op === "%")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((((${l}) % (${r})) << 24) >> 24)))`;
-			if (op === "<<" || op === ">>") {
-				return `((${r}) >= 8 ? (${op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0"}) : (((${l}) ${op} (${r})) << 24 >> 24))`;
-			}
-			if (op === "&^") return `((((${l}) & ~(${r})) << 24) >> 24)`;
-			return `((((${l} ${op} ${r})) << 24) >> 24)`;
-		}
-		if (tName === "int16") {
+		const divZero =
+			'(() => { throw new Error("runtime error: integer divide by zero"); })()';
+		if (tName === "int32" || tName === "rune" || tName === "uint32") {
+			const signed = tName !== "uint32";
+			const cast = signed ? "| 0" : ">>> 0";
+			if (signed && op === "*") return `Math.imul(${l}, ${r})`;
 			if (op === "/")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : ((Math.trunc((${l}) / (${r})) << 16) >> 16))`;
+				return `((${r}) === 0 ? ${divZero} : (Math.trunc((${l}) / (${r})) ${cast}))`;
 			if (op === "%")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((((${l}) % (${r})) << 16) >> 16)))`;
+				return `((${r}) === 0 ? ${divZero} : (((${l}) % (${r})) ${cast}))`;
 			if (op === "<<" || op === ">>") {
-				return `((${r}) >= 16 ? (${op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0"}) : (((${l}) ${op} (${r})) << 16 >> 16))`;
+				const ovf = signed && op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0";
+				const jsOp = !signed && op === ">>" ? ">>>" : op;
+				return `((${r}) >= 32 ? ${ovf} : ((${l}) ${jsOp} (${r}))) ${cast}`;
 			}
-			if (op === "&^") return `((((${l}) & ~(${r})) << 16) >> 16)`;
-			return `((((${l} ${op} ${r})) << 16) >> 16)`;
+			if (op === "&^") return `((${l}) & ~(${r})) ${cast}`;
+			return `((${l} ${op} ${r}) ${cast})`;
 		}
-		if (tName === "uint8" || tName === "byte") {
+		if (tName === "int8" || tName === "int16") {
+			const bits = tName === "int8" ? 8 : 16;
+			const sh = 32 - bits;
 			if (op === "/")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (Math.trunc((${l}) / (${r})) & 0xFF))`;
+				return `((${r}) === 0 ? ${divZero} : ((Math.trunc((${l}) / (${r})) << ${sh}) >> ${sh}))`;
 			if (op === "%")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((${l}) % (${r})) & 0xFF))`;
+				return `((${r}) === 0 ? ${divZero} : (((((${l}) % (${r})) << ${sh}) >> ${sh})))`;
 			if (op === "<<" || op === ">>") {
-				const jsOp = op === ">>" ? ">>>" : "<<";
-				return `((${r}) >= 8 ? 0 : (((${l}) ${jsOp} (${r})) & 0xFF))`;
+				return `((${r}) >= ${bits} ? (${op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0"}) : (((${l}) ${op} (${r})) << ${sh} >> ${sh}))`;
 			}
-			if (op === "&^") return `(((${l}) & ~(${r})) & 0xFF)`;
-			return `((${l} ${op} ${r}) & 0xFF)`;
+			if (op === "&^") return `((((${l}) & ~(${r})) << ${sh}) >> ${sh})`;
+			return `((((${l} ${op} ${r})) << ${sh}) >> ${sh})`;
 		}
-		if (tName === "uint16") {
+		if (tName === "uint8" || tName === "byte" || tName === "uint16") {
+			const bits = tName === "uint16" ? 16 : 8;
+			const mask = bits === 16 ? "0xFFFF" : "0xFF";
 			if (op === "/")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (Math.trunc((${l}) / (${r})) & 0xFFFF))`;
+				return `((${r}) === 0 ? ${divZero} : (Math.trunc((${l}) / (${r})) & ${mask}))`;
 			if (op === "%")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((${l}) % (${r})) & 0xFFFF))`;
+				return `((${r}) === 0 ? ${divZero} : (((${l}) % (${r})) & ${mask}))`;
 			if (op === "<<" || op === ">>") {
 				const jsOp = op === ">>" ? ">>>" : "<<";
-				return `((${r}) >= 16 ? 0 : (((${l}) ${jsOp} (${r})) & 0xFFFF))`;
+				return `((${r}) >= ${bits} ? 0 : (((${l}) ${jsOp} (${r})) & ${mask}))`;
 			}
-			if (op === "&^") return `(((${l}) & ~(${r})) & 0xFFFF)`;
-			return `((${l} ${op} ${r}) & 0xFFFF)`;
+			if (op === "&^") return `(((${l}) & ~(${r})) & ${mask})`;
+			return `((${l} ${op} ${r}) & ${mask})`;
 		}
 		if (this.isIntType(type)) {
 			if (op === "/")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : Math.trunc((${l}) / (${r})))`;
-			if (op === "%")
-				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : ((${l}) % (${r})))`;
+				return `((${r}) === 0 ? ${divZero} : Math.trunc((${l}) / (${r})))`;
+			if (op === "%") return `((${r}) === 0 ? ${divZero} : ((${l}) % (${r})))`;
 		}
 		return `${l} ${op} ${r}`;
 	},