gofront 1.4.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.4.0",
+	"version": "1.6.0",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -11,12 +11,15 @@
 		"url": "https://github.com/seriva/gofront/issues"
 	},
 	"homepage": "https://github.com/seriva/gofront#readme",
-	"description": "A Go-inspired language that transpiles to JavaScript",
+	"description": "A Go-inspired language that compiles to JavaScript and WebAssembly",
 	"keywords": [
 		"go",
 		"compiler",
 		"transpiler",
 		"javascript",
+		"webassembly",
+		"wasm",
+		"wasmgc",
 		"frontend",
 		"type-safe"
 	],
@@ -31,30 +34,24 @@
 		"gofront": "./src/index.js"
 	},
 	"scripts": {
-		"build:simple": "node src/index.js example/simple/src -o example/simple/app.js",
-		"build:reactive": "node src/index.js example/reactive/src -o example/reactive/app.js",
-		"build:gom": "node src/index.js example/gom/src -o example/gom/app.js",
-		"build:templ": "node src/index.js example/templ/src -o example/templ/app.js",
-		"build:webgl": "node src/index.js example/webgl/src -o example/webgl/app.js",
-		"build:all": "npm run build:simple && npm run build:reactive && npm run build:gom && npm run build:templ && npm run build:webgl",
-		"test": "npm run test:unit",
-		"test:all": "npm run test:unit && npm run test:perf && npm run test:examples && npm run test:examples:dom && npm run test:e2e",
-		"test:unit": "node test/unit/run.js",
-		"test:perf": "node test/e2e/perf/zero-alloc.js",
-		"test:examples": "node src/index.js test example/simple/src && node src/index.js test example/simple/src/utils && node src/index.js test example/reactive/src && node src/index.js test example/reactive/src/utils && node src/index.js test example/gom/src && node src/index.js test example/gom/src/utils && node src/index.js test example/templ/src && node src/index.js test example/templ/src/utils",
-		"test:examples:dom": "node src/index.js test --dom example/simple/src && node src/index.js test --dom example/gom/src && node src/index.js test --dom example/templ/src",
+		"build": "node src/index.js example/simple/src -o example/simple/app.js && node src/index.js example/reactive/src -o example/reactive/app.js && node src/index.js example/gom/src -o example/gom/app.js && node src/index.js example/templ/src -o example/templ/app.js && node src/index.js example/webgl/src -o example/webgl/app.js && node src/index.js example/hybrid/src -o example/hybrid/app.js",
+		"test": "node test/unit/run.js && node test/e2e/perf/zero-alloc.js && node src/index.js test --dom example/...",
+		"test:e2e": "playwright test",
 		"test:coverage": "c8 --include='src/**' --reporter=text --reporter=lcov node test/unit/run.js",
-		"test:e2e": "npm run build:all && playwright test",
+		"bench": "node --expose-gc test/e2e/perf/raycast-bench.js",
 		"format": "biome format --write .",
-		"check": "biome check . && sentrux check && sentrux gate && node src/index.js example/simple/src --check && node src/index.js example/reactive/src --check && node src/index.js example/gom/src --check && node src/index.js example/templ/src --check && node src/index.js example/webgl/src --check",
+		"check": "biome check . && sentrux check && sentrux gate && node src/index.js check example/...",
 		"prepare": "lefthook install"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.5.14",
+		"@biomejs/biome": "^2.5.15",
 		"@playwright/test": "^1.63.0",
 		"c8": "^12.0.0",
-		"jsdom": "^30.1.0",
-		"lefthook": "^2.1.14",
+		"jsdom": "^30.1.2",
+		"lefthook": "^2.1.17",
 		"serve": "^14.2.6"
+	},
+	"optionalDependencies": {
+		"binaryen": "^132.0.0"
 	}
 }

package/src/{codegen → backend/js}/expressions.js

@@ -1,12 +1,78 @@
+import {
+	closureMutates,
+	fnMutates,
+	nodeMutatesVar,
+	nodeWritesVar,
+	rootIdentName,
+} from "../../lower/index.js";
 import {
 	ERROR,
 	isComplex,
 	isTypedArraySlice,
 	typedArrayConstructorForElem,
-} from "../typechecker/types.js";
+} from "../../typechecker/types.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
+const STRICT_NUMERIC_TYPES = new Set([
+	"float32",
+	"int8",
+	"int16",
+	"int32",
+	"rune",
+	"uint8",
+	"byte",
+	"uint16",
+	"uint32",
+]);
+
+const STRICT_OPS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"&",
+	"|",
+	"^",
+	"&^",
+	"<<",
+	">>",
+]);
+
+// 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) {
+	if (js.endsWith("]")) {
+		let depth = 0;
+		let quote = null;
+		for (let i = js.length - 1; i >= 0; i--) {
+			const ch = js[i];
+			if (quote) {
+				if (ch === quote && js[i - 1] !== "\\") quote = null;
+				continue;
+			}
+			if (ch === '"' || ch === "'" || ch === "`") quote = ch;
+			else if (ch === "]" || ch === ")") depth++;
+			else if (ch === "[" || ch === "(") {
+				depth--;
+				if (depth === 0 && ch === "[" && i > 0)
+					return { obj: js.slice(0, i), key: js.slice(i + 1, -1) };
+			}
+		}
+		return null;
+	}
+	const m = /^(.*[^.])\.([A-Za-z_$][\w$]*)$/s.exec(js);
+	if (!m) return null;
+	// Only split when the dot is at nesting depth 0, e.g. not inside `f(a.b)`.
+	let depth = 0;
+	for (const ch of m[1]) {
+		if (ch === "(" || ch === "[") depth++;
+		else if (ch === ")" || ch === "]") depth--;
+	}
+	return depth === 0 ? { obj: m[1], prop: m[2] } : null;
+}
+
 // Namespace constants: pkg.Field → JS literal
 const NS_CONSTANTS = {
 	math: {
@@ -144,7 +210,7 @@ const TYPEOF_NUMBER_NAMES = new Set([...INT_TYPE_NAMES, "float32", "float64"]);
 const BUILTIN_GEN = {
 	append: (s, e) => s.genAppend(e),
 	len: (s, e) => s._genBuiltinLen(e),
-	cap: (s, e) => `${s.genExpr(e.args[0])}.length`,
+	cap: (s, e) => `(${s.genExpr(e.args[0])}?.length ?? 0)`,
 	make: (s, e) => s.genMake(e),
 	delete: (s, e) => {
 		const [m, k] = e.args.map((a) => s.genExpr(a));
@@ -167,14 +233,19 @@ const BUILTIN_GEN = {
 		}
 		return `{ value: ${s.zeroValueForExpr(arg)} }`;
 	},
-	print: (s, e) => `console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
+	// `print` writes without a trailing newline (Go semantics); the wasm glue
+	// buffers the same way, so output parity holds across backends.
+	print: (s, e) =>
+		`((__s) => (typeof process !== "undefined" && process?.stdout?.write ? process.stdout.write(__s) : console.log(__s)))([${e.args.map((a) => s.genExpr(a)).join(", ")}].map(String).join(" "))`,
 	println: (s, e) =>
 		`console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
 	panic: (s, e) => `(() => { throw new Error(${s.genExpr(e.args[0])}); })()`,
-	recover: () =>
-		`(typeof __panic !== "undefined" && __panic !== null ? (() => { const __r = __panic.message ?? String(__panic); __panic = null; return __r; })() : null)`,
+	recover: (s) => {
+		s.useHelper("panicRt");
+		return `__recover(${s._recoverOkInScope ? "__recoverOk" : "false"})`;
+	},
 	error: (s, e) => {
-		s._usesError = true;
+		s.useHelper("error");
 		return `__error(${s.genExpr(e.args[0])})`;
 	},
 	min: (s, e) => `Math.min(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
@@ -206,7 +277,7 @@ export const expressionGenMethods = {
 		if (expr._ifaceBox && !expr._ifaceBoxing) {
 			expr._ifaceBoxing = true;
 			try {
-				this._usesIfaceBox = true;
+				this.useHelper("ifaceBox");
 				const fn = expr._ifaceBox === "ptr" ? "__ifp" : "__ifv";
 				return `${fn}(${this.genExpr(expr)})`;
 			} finally {
@@ -299,7 +370,7 @@ export const expressionGenMethods = {
 		if (base.kind === "struct") {
 			if (this._structClassName(t) || this._structClassName(base))
 				return `${js}.__clone()`;
-			this._usesSClone = true;
+			this.useHelper("sclone");
 			return `__sclone(${js})`;
 		}
 		const elemClone = this._cloneJs(base.elem, "__e");
@@ -335,60 +406,21 @@ export const expressionGenMethods = {
 	},
 
 	_rootIdentName(e) {
-		while (e) {
-			if (e.kind === "Ident") return e.name;
-			if (e.kind === "SelectorExpr" || e.kind === "IndexExpr") e = e.expr;
-			else if (e.kind === "UnaryExpr" && e.op === "*") e = e.operand;
-			else return null;
-		}
-		return null;
+		return rootIdentName(e);
 	},
 
 	// True when `node` itself (not its children) writes to variable `name`.
 	_nodeWritesVar(node, name) {
-		const root = (e) => this._rootIdentName(e) === name;
-		switch (node.kind) {
-			case "AssignStmt":
-				return node.lhs.some(root);
-			case "DefineStmt":
-				return node.lhs.some((e) => e._redecl && e.name === name);
-			case "IncDecStmt":
-				return root(node.expr);
-			case "SelectorExpr":
-				return Boolean(
-					node._isMethodValue && node._type?._ptrRecv && root(node.expr),
-				);
-			default:
-				return false;
-		}
+		return nodeWritesVar(node, name);
 	},
 
 	// True when `node` may modify (or take the address of) the value held by variable `name`.
 	_nodeMutatesVar(node, name, addrOnly = false) {
-		if (!node || typeof node !== "object") return false;
-		if (Array.isArray(node))
-			return node.some((n) => this._nodeMutatesVar(n, name, addrOnly));
-		if (
-			node.kind === "UnaryExpr" &&
-			node.op === "&" &&
-			this._rootIdentName(node.operand) === name
-		)
-			return true;
-		if (!addrOnly && this._nodeWritesVar(node, name)) return true;
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			if (this._nodeMutatesVar(node[key], name, addrOnly)) return true;
-		}
-		return false;
+		return nodeMutatesVar(node, name, addrOnly);
 	},
 
 	_fnMutates(name, addrOnly = false) {
-		const ctx = this._fnCtx;
-		if (!ctx) return true;
-		const key = `${addrOnly ? "&" : ""}${name}`;
-		if (!ctx.mut.has(key))
-			ctx.mut.set(key, this._nodeMutatesVar(ctx.body, name, addrOnly));
-		return ctx.mut.get(key);
+		return fnMutates(this._fnCtx?.body, name, addrOnly, this._fnCtx?.mut);
 	},
 
 	_withFnCtx(body, fn) {
@@ -447,21 +479,7 @@ export const expressionGenMethods = {
 	},
 
 	_closureMutates(name) {
-		const ctx = this._fnCtx;
-		const key = `λ${name}`;
-		if (!ctx.mut.has(key)) {
-			const walk = (node) => {
-				if (!node || typeof node !== "object") return false;
-				if (Array.isArray(node)) return node.some(walk);
-				if (node.kind === "FuncLit")
-					return this._nodeMutatesVar(node.body, name);
-				return Object.keys(node).some(
-					(k) => !k.startsWith("_") && walk(node[k]),
-				);
-			};
-			ctx.mut.set(key, walk(ctx.body));
-		}
-		return ctx.mut.get(key);
+		return closureMutates(this._fnCtx?.body, name, this._fnCtx?.mut);
 	},
 
 	_genUnaryExpr(expr) {
@@ -600,7 +618,7 @@ export const expressionGenMethods = {
 		this._withFnCtx(expr.body, () =>
 			this.indented(() => {
 				this._emitParamCopies(expr.params);
-				this._genBody(expr.body);
+				this._genBody(expr.body, expr);
 			}),
 		);
 		const body = this.out.join("\n");
@@ -689,12 +707,20 @@ export const expressionGenMethods = {
 			return this._genTimeMethodCall(expr.func.field, expr);
 		if (recvName === "testing.T")
 			return this._genTestingMethodCall(expr.func.field, expr);
+		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})`;
+		}
 		return undefined;
 	},
 
 	_genSelectorCall(expr) {
-		if (this._isErrorMethodCall(expr))
-			return `${this.genExpr(expr.func.expr)}.Error()`;
+		if (this._isErrorMethodCall(expr)) {
+			const recv = this.genExpr(expr.func.expr);
+			if (!this.strict) return `${recv}.Error()`;
+			this.useHelper("nilCall");
+			return `__nilcall(${recv}).Error()`;
+		}
 		if (expr.func.expr.kind === "Ident") {
 			const ns = expr.func.expr.name;
 			const fn = expr.func.field;
@@ -703,7 +729,25 @@ export const expressionGenMethods = {
 		}
 		const recvType = expr.func.expr._type;
 		const recvName = this._resolveRecvName(recvType);
-		return this._genReceiverTypeCall(recvName, expr);
+		const typed = this._genReceiverTypeCall(recvName, expr);
+		if (typed !== undefined) return typed;
+		if (this.strict && this._isInterfaceType(recvType)) {
+			// Go panics with a nil-dereference runtime error; JS would throw a
+			// TypeError with a different message.
+			this.useHelper("nilCall");
+			const recv = this.genExpr(expr.func.expr);
+			const args = expr.args
+				.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
+				.join(", ");
+			return `__nilcall(${recv}).${expr.func.field}(${args})`;
+		}
+		return undefined;
+	},
+
+	_isInterfaceType(t) {
+		if (!t) return false;
+		if (t.kind === "interface") return true;
+		return t.kind === "named" && t.underlying?.kind === "interface";
 	},
 
 	_genBuiltinLen(expr) {
@@ -714,7 +758,7 @@ export const expressionGenMethods = {
 		if (wrapField) return `${this.genExpr(arg)}.${wrapField}.length`;
 		const js = this.genExpr(arg);
 		if (t?.kind === "map") return `Object.keys(${js}).length`;
-		this._usesLen = true;
+		this.useHelper("len");
 		return `__len(${js})`;
 	},
 
@@ -747,7 +791,7 @@ export const expressionGenMethods = {
 					a._spread ? `...${this.genExpr(a)}` : this.genValueExpr(a),
 				);
 			if (elems.length === 0) return this.genExpr(expr.args[0]);
-			this._usesAppend = true;
+			this.useHelper("append");
 			return `new ${retType.name}(__append(${sliceJS}, ${elems.join(", ")}))`;
 		}
 		const slice = this.genExpr(expr.args[0]);
@@ -755,7 +799,7 @@ export const expressionGenMethods = {
 			.slice(1)
 			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genValueExpr(a)));
 		if (elems.length === 0) return slice;
-		this._usesAppend = true;
+		this.useHelper("append");
 		const sliceType = expr._type ?? expr.args[0]._type;
 		const typedCtor = isTypedArraySlice(sliceType)
 			? typedArrayConstructorForElem(
@@ -1227,10 +1271,10 @@ export const expressionGenMethods = {
 			case "-":
 				return `{ re: ${l}.re - ${r}.re, im: ${l}.im - ${r}.im }`;
 			case "*":
-				this._usesCmul = true;
+				this.useHelper("cmul");
 				return `__cmul(${l}, ${r})`;
 			case "/":
-				this._usesCdiv = true;
+				this.useHelper("cdiv");
 				return `__cdiv(${l}, ${r})`;
 			case "==":
 				return `(${l}.re === ${r}.re && ${l}.im === ${r}.im)`;
@@ -1248,11 +1292,17 @@ export const expressionGenMethods = {
 			return this._genComplexBinary(expr);
 
 		if (this._isStructEquality(expr)) {
-			this._usesEqual = true;
+			this.useHelper("equal");
 			const cmp = `__equal(${this.genExpr(expr.left)}, ${this.genExpr(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);
+			return this._genStrictBinary(expr.op, l, r, expr._type);
+		}
+
 		const jsOp = this._emittedBinaryOp(expr) ?? "/";
 		const operand = (child, isRight) =>
 			wrapForJsOp(
@@ -1327,7 +1377,7 @@ export const expressionGenMethods = {
 			return this._genSliceTypeConversion(expr, inner, t);
 		const target = t?.name;
 		if (target === "error") {
-			this._usesError = true;
+			this.useHelper("error");
 			return `__error(${inner})`;
 		}
 		if (target && this.namedWrapperNames.has(target))
@@ -1422,4 +1472,142 @@ export const expressionGenMethods = {
 				return inner;
 		}
 	},
+
+	_typeName(t) {
+		if (!t) return null;
+		if (t.kind === "untyped") return t.base;
+		if (t.kind === "named") return this._typeName(t.underlying);
+		if (t.kind === "basic") return t.name;
+		return null;
+	},
+
+	_isStrictAtomicOp(_op, typeName) {
+		return STRICT_NUMERIC_TYPES.has(typeName);
+	},
+
+	_needsStrictOp(op, type) {
+		if (!STRICT_OPS.has(op)) return false;
+		if (this._isStrictAtomicOp(op, this._typeName(type))) return true;
+		return this.isIntType(type) && (op === "/" || op === "%");
+	},
+
+	// Emits `lhs = strict(lhs op rhs)` for any lvalue shape; returns false when not applicable.
+	// Indexed / nested targets are split into object + key temps so sub-expressions run once.
+	_genStrictCompound(lhsNode, op, rhsJs, srcLine = null, lhsJs = null) {
+		const type = lhsNode._type;
+		if (!this._needsStrictOp(op, type)) return false;
+		if (lhsNode.kind === "IndexExpr" && lhsNode.expr?._type?.kind === "map")
+			return false;
+		const l = lhsJs ?? this._genAssignLhsExpr(lhsNode);
+		if (/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(l)) {
+			this.line(
+				`${l} = ${this._genStrictBinary(op, l, rhsJs, type)};`,
+				srcLine,
+			);
+			return true;
+		}
+		const split = splitLastAccess(l);
+		if (!split) return false;
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const o = `__o${this._tmpCounter}`;
+		if (split.key != null) {
+			const k = `__k${this._tmpCounter}`;
+			const target = `${o}[${k}]`;
+			this.line(
+				`{ const ${o} = ${split.obj}, ${k} = ${split.key}; ${target} = ${this._genStrictBinary(op, target, rhsJs, type)}; }`,
+				srcLine,
+			);
+		} else {
+			const target = `${o}.${split.prop}`;
+			this.line(
+				`{ const ${o} = ${split.obj}; ${target} = ${this._genStrictBinary(op, target, rhsJs, type)}; }`,
+				srcLine,
+			);
+		}
+		return true;
+	},
+
+	_genStrictBinary(op, l, r, type) {
+		const tName = this._typeName(type);
+		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") {
+			if (op === "/")
+				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : ((Math.trunc((${l}) / (${r})) << 16) >> 16))`;
+			if (op === "%")
+				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((((${l}) % (${r})) << 16) >> 16)))`;
+			if (op === "<<" || op === ">>") {
+				return `((${r}) >= 16 ? (${op === ">>" ? `((${l}) < 0 ? -1 : 0)` : "0"}) : (((${l}) ${op} (${r})) << 16 >> 16))`;
+			}
+			if (op === "&^") return `((((${l}) & ~(${r})) << 16) >> 16)`;
+			return `((((${l} ${op} ${r})) << 16) >> 16)`;
+		}
+		if (tName === "uint8" || tName === "byte") {
+			if (op === "/")
+				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (Math.trunc((${l}) / (${r})) & 0xFF))`;
+			if (op === "%")
+				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((${l}) % (${r})) & 0xFF))`;
+			if (op === "<<" || op === ">>") {
+				const jsOp = op === ">>" ? ">>>" : "<<";
+				return `((${r}) >= 8 ? 0 : (((${l}) ${jsOp} (${r})) & 0xFF))`;
+			}
+			if (op === "&^") return `(((${l}) & ~(${r})) & 0xFF)`;
+			return `((${l} ${op} ${r}) & 0xFF)`;
+		}
+		if (tName === "uint16") {
+			if (op === "/")
+				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (Math.trunc((${l}) / (${r})) & 0xFFFF))`;
+			if (op === "%")
+				return `((${r}) === 0 ? (() => { throw new Error("runtime error: integer divide by zero"); })() : (((${l}) % (${r})) & 0xFFFF))`;
+			if (op === "<<" || op === ">>") {
+				const jsOp = op === ">>" ? ">>>" : "<<";
+				return `((${r}) >= 16 ? 0 : (((${l}) ${jsOp} (${r})) & 0xFFFF))`;
+			}
+			if (op === "&^") return `(((${l}) & ~(${r})) & 0xFFFF)`;
+			return `((${l} ${op} ${r}) & 0xFFFF)`;
+		}
+		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 `${l} ${op} ${r}`;
+	},
 };