gofront 0.0.4 → 0.0.6

package/src/codegen/expressions.js

@@ -1,5 +1,9 @@
 // CodeGen expression methods and helpers — installed as a mixin on CodeGen.prototype.
 
+import { ERROR, isComplex } from "../typechecker/types.js";
+
+const globalError = ERROR;
+
 const INT_TYPE_NAMES = new Set([
 	"int",
 	"uint",
@@ -23,17 +27,68 @@ export const expressionGenMethods = {
 				if (expr.litKind === "STRING") return JSON.stringify(expr.value);
 				return expr.value; // int, float, bool, nil(null)
 
+			case "ImagLit":
+				return `{ re: 0, im: ${expr.value} }`;
+
 			case "Ident":
+				if (this._boxedVars.has(expr.name) && !expr._isAddressOf)
+					return `${expr.name}.value`;
 				return expr.name;
 
 			case "UnaryExpr": {
 				const op = expr.op === "^" ? "~" : expr.op; // bitwise NOT
-				// Dereference/address-of — transparent in JS
-				if (op === "*" || op === "&") return this.genExpr(expr.operand);
+				// Address-of: &x
+				if (op === "&") {
+					if (expr.operand.kind === "Ident") {
+						// Mark so Ident codegen does NOT append .value
+						expr.operand._isAddressOf = true;
+						// For boxed vars, &x returns the box itself
+						if (this._boxedVars.has(expr.operand.name)) {
+							return this.genExpr(expr.operand);
+						}
+					}
+					// For non-boxed vars (structs, etc.), wrap in { value: x }
+					return `{ value: ${this.genExpr(expr.operand)} }`;
+				}
+				// Dereference: *p → p.value
+				if (op === "*") {
+					return `${this.genExpr(expr.operand)}.value`;
+				}
+				// Unary minus/plus on complex
+				if ((op === "-" || op === "+") && isComplex(expr.operand._type)) {
+					const inner = this.genExpr(expr.operand);
+					if (op === "-") return `{ re: -${inner}.re, im: -${inner}.im }`;
+					return inner;
+				}
 				return `${op}${this.genExpr(expr.operand)}`;
 			}
 
 			case "BinaryExpr": {
+				// Complex binary operations
+				if (
+					isComplex(expr._type) ||
+					isComplex(expr.left._type) ||
+					isComplex(expr.right._type)
+				) {
+					const l = this._genComplexOperand(expr.left);
+					const r = this._genComplexOperand(expr.right);
+					switch (expr.op) {
+						case "+":
+							return `{ re: ${l}.re + ${r}.re, im: ${l}.im + ${r}.im }`;
+						case "-":
+							return `{ re: ${l}.re - ${r}.re, im: ${l}.im - ${r}.im }`;
+						case "*":
+							this._usesCmul = true;
+							return `__cmul(${l}, ${r})`;
+						case "/":
+							this._usesCdiv = true;
+							return `__cdiv(${l}, ${r})`;
+						case "==":
+							return `(${l}.re === ${r}.re && ${l}.im === ${r}.im)`;
+						case "!=":
+							return `(${l}.re !== ${r}.re || ${l}.im !== ${r}.im)`;
+					}
+				}
 				const l = this.genExpr(expr.left);
 				const r = this.genExpr(expr.right);
 				// Integer division: only when both sides are int
@@ -66,6 +121,9 @@ export const expressionGenMethods = {
 			case "CallExpr":
 				return this.genCall(expr);
 
+			case "InstantiationExpr":
+				return this.genExpr(expr.expr); // type erasure
+
 			case "SelectorExpr": {
 				// Method expression: TypeName.MethodName → (recv, ...args) => recv.method(...args)
 				if (expr._isMethodExpr) {
@@ -112,7 +170,7 @@ export const expressionGenMethods = {
 				const base = this.genExpr(expr.expr);
 				// Bundled GoFront packages are inlined — drop the qualifier.
 				if (this.bundledPackages.has(base)) return expr.field;
-				// Pointer types are wrapped as { value: T }; route through .value
+				// Pointer types: route through .value
 				if (expr.expr._type?.kind === "pointer" && expr.field !== "value") {
 					const sel = `${base}.value.${expr.field}`;
 					if (expr._isMethodValue && !expr._callee)
@@ -164,10 +222,14 @@ export const expressionGenMethods = {
 				const params = expr.params.map((p) => p.name).join(", ");
 				const asyncPrefix = expr.async ? "async " : "";
 				const saved = this.out;
+				const prevBoxed = this._boxedVars;
+				this._boxedVars = new Set(prevBoxed); // inherit parent's boxed vars (closures)
+				this._scanAddressTaken(expr.body);
 				this.out = [];
 				this.indented(() => this._genBody(expr.body));
 				const body = this.out.join("\n");
 				this.out = saved;
+				this._boxedVars = prevBoxed;
 				return `${asyncPrefix}function(${params}) {\n${body}\n${"  ".repeat(this.indent)}}`;
 			}
 
@@ -175,6 +237,26 @@ export const expressionGenMethods = {
 				const inner = this.genExpr(expr.expr);
 				const t = expr.targetType;
 
+				// Complex type conversions
+				if (t?.name === "complex128" || t?.name === "complex64") {
+					const srcType = expr.expr._type;
+					if (isComplex(srcType)) return inner; // complex→complex identity
+					return `{ re: ${inner}, im: 0 }`; // numeric→complex
+				}
+
+				// Array type conversion: [N]T(slice) → slice(0, N)
+				if (t?.kind === "ArrayType") {
+					const srcType = expr.expr._type;
+					const srcResolved =
+						srcType?.kind === "named" ? srcType.underlying : srcType;
+					if (srcResolved?.kind === "slice") {
+						const size =
+							t.size?.value !== undefined ? Number(t.size.value) : t.size;
+						return `${inner}.slice(0, ${size})`;
+					}
+					return inner;
+				}
+
 				// Slice type conversions
 				if (t?.kind === "SliceType") {
 					const elem = t.elem?.name;
@@ -197,6 +279,11 @@ export const expressionGenMethods = {
 				}
 
 				const target = t?.name;
+				// error("msg") → __error("msg")
+				if (target === "error") {
+					this._usesError = true;
+					return `__error(${inner})`;
+				}
 				switch (target) {
 					case "string": {
 						// Go string(65) → "A" (Unicode code point), not "65"
@@ -204,6 +291,14 @@ export const expressionGenMethods = {
 						if (srcType && this.isIntType(srcType)) {
 							return `String.fromCodePoint(${inner})`;
 						}
+						// string([]byte) → decode byte array to string
+						if (
+							srcType &&
+							srcType.kind === "slice" &&
+							srcType.elem?.name === "int"
+						) {
+							return `${inner}.map(c => String.fromCharCode(c)).join("")`;
+						}
 						return `String(${inner})`;
 					}
 					case "int":
@@ -244,12 +339,16 @@ export const expressionGenMethods = {
 	},
 
 	genCall(expr) {
+		// Unwrap InstantiationExpr for function calls: Foo[int](42) → Foo(42)
+		const funcExpr =
+			expr.func.kind === "InstantiationExpr" ? expr.func.expr : expr.func;
 		// Handle built-ins that need special JS translation
-		if (expr.func.kind === "Ident") {
-			switch (expr.func.name) {
+		if (funcExpr.kind === "Ident") {
+			switch (funcExpr.name) {
 				case "append":
 					return this.genAppend(expr);
 				case "len": {
+					if (expr._constLen != null) return String(expr._constLen);
 					const arg = expr.args[0];
 					const t = arg?._type;
 					const js = this.genExpr(arg);
@@ -285,9 +384,9 @@ export const expressionGenMethods = {
 				case "recover":
 					return `(typeof __panic !== "undefined" && __panic !== null ? (() => { const __r = __panic.message ?? String(__panic); __panic = null; return __r; })() : null)`;
 				case "error": {
-					// errors are plain strings; nil (null) means no error
+					this._usesError = true;
 					const arg = this.genExpr(expr.args[0]);
-					return arg;
+					return `__error(${arg})`;
 				}
 				case "min": {
 					const args = expr.args.map((a) => this.genExpr(a)).join(", ");
@@ -309,263 +408,51 @@ export const expressionGenMethods = {
 					}
 					return `(${js}).length = 0`;
 				}
+				case "complex": {
+					const re = this.genExpr(expr.args[0]);
+					const im = this.genExpr(expr.args[1]);
+					return `{ re: ${re}, im: ${im} }`;
+				}
+				case "real":
+					return `(${this.genExpr(expr.args[0])}).re`;
+				case "imag":
+					return `(${this.genExpr(expr.args[0])}).im`;
 			}
 		}
 
-		// error.Error() → the error string itself (errors are plain strings at runtime)
+		// error.Error() → real method call
 		if (
 			expr.func.kind === "SelectorExpr" &&
 			expr.func.field === "Error" &&
-			expr.func.expr._type?.name === "error"
+			expr.func.expr._type &&
+			(expr.func.expr._type === globalError ||
+				expr.func.expr._type?.name === "error" ||
+				(expr.func.expr._type?.kind === "named" &&
+					expr.func.expr._type?.underlying?.kind === "interface"))
 		) {
-			return this.genExpr(expr.func.expr);
+			return `${this.genExpr(expr.func.expr)}.Error()`;
 		}
 
 		// fmt.Sprintf / fmt.Printf / fmt.Println / fmt.Print / fmt.Errorf
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "fmt"
-		) {
-			const fmtArgs = expr.args.map((a) => this.genExpr(a)).join(", ");
-			switch (expr.func.field) {
-				case "Sprintf":
-				case "Errorf":
-					this._usesSprintf = true;
-					return `__sprintf(${fmtArgs})`;
-				case "Printf":
-				case "Print":
-					this._usesSprintf = true;
-					return `process?.stdout?.write(__sprintf(${fmtArgs}))`;
-				case "Println":
-					this._usesSprintf = true;
-					return `console.log(__sprintf(${fmtArgs}))`;
-			}
-		}
-
-		// strings.* — direct JS string method mappings
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "strings"
-		) {
-			const a = expr.args.map((e) => this.genExpr(e));
-			switch (expr.func.field) {
-				case "Contains":
-					return `${a[0]}.includes(${a[1]})`;
-				case "HasPrefix":
-					return `${a[0]}.startsWith(${a[1]})`;
-				case "HasSuffix":
-					return `${a[0]}.endsWith(${a[1]})`;
-				case "Index":
-					return `${a[0]}.indexOf(${a[1]})`;
-				case "LastIndex":
-					return `${a[0]}.lastIndexOf(${a[1]})`;
-				case "Count":
-					return `${a[0]}.split(${a[1]}).length - 1`;
-				case "Repeat":
-					return `${a[0]}.repeat(${a[1]})`;
-				case "Replace":
-					return `${a[0]}.replace(${a[1]}, ${a[2]})`;
-				case "ReplaceAll":
-					return `${a[0]}.replaceAll(${a[1]}, ${a[2]})`;
-				case "ToUpper":
-					return `${a[0]}.toUpperCase()`;
-				case "ToLower":
-					return `${a[0]}.toLowerCase()`;
-				case "TrimSpace":
-					return `${a[0]}.trim()`;
-				case "Trim":
-					return `${a[0]}.replace(new RegExp(\`^[\${${a[1]}}]+|[\${${a[1]}}]+$\`, "g"), "")`;
-				case "TrimPrefix":
-					return `(${a[0]}.startsWith(${a[1]}) ? ${a[0]}.slice(${a[1]}.length) : ${a[0]})`;
-				case "TrimSuffix":
-					return `(${a[0]}.endsWith(${a[1]}) ? ${a[0]}.slice(0, -${a[1]}.length) : ${a[0]})`;
-				case "TrimLeft":
-					return `${a[0]}.replace(new RegExp(\`^[\${${a[1]}}]+\`), "")`;
-				case "TrimRight":
-					return `${a[0]}.replace(new RegExp(\`[\${${a[1]}}]+$\`), "")`;
-				case "Split":
-					return `${a[0]}.split(${a[1]})`;
-				case "Join":
-					return `${a[0]}.join(${a[1]})`;
-				case "EqualFold":
-					return `${a[0]}.toLowerCase() === ${a[1]}.toLowerCase()`;
-			}
-		}
-
-		// strconv.* — number/string conversion
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "strconv"
-		) {
-			const a = expr.args.map((e) => this.genExpr(e));
-			switch (expr.func.field) {
-				case "Itoa":
-					return `String(${a[0]})`;
-				case "Atoi":
-					return `(Number.isNaN(Number(${a[0]})) ? [0, "invalid syntax"] : [Number(${a[0]}) | 0, null])`;
-				case "FormatBool":
-					return `String(${a[0]})`;
-				case "FormatInt":
-					return `(${a[0]}).toString(${a[1]})`;
-				case "FormatFloat":
-					return `String(${a[0]})`;
-				case "ParseFloat":
-					return `(Number.isNaN(Number(${a[0]})) ? [0, "invalid syntax"] : [Number(${a[0]}), null])`;
-				case "ParseInt":
-					return `(Number.isNaN(parseInt(${a[0]}, ${a[1]} || 10)) ? [0, "invalid syntax"] : [parseInt(${a[0]}, ${a[1]} || 10), null])`;
-				case "ParseBool":
-					return `(${a[0]} === "true" || ${a[0]} === "1" ? [true, null] : ${a[0]} === "false" || ${a[0]} === "0" ? [false, null] : [false, "invalid syntax"])`;
-			}
-		}
-
-		// sort.* — in-place sorting
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "sort"
-		) {
-			const a = expr.args.map((e) => this.genExpr(e));
-			switch (expr.func.field) {
-				case "Ints":
-				case "Float64s":
-					return `${a[0]}.sort((a, b) => a - b)`;
-				case "Strings":
-					return `${a[0]}.sort()`;
-				case "Slice":
-					return `${a[0]}.sort((a, b) => ${a[1]}(a, b) ? -1 : ${a[1]}(b, a) ? 1 : 0)`;
-				case "SliceStable":
-					return `${a[0]}.sort((a, b) => ${a[1]}(a, b) ? -1 : ${a[1]}(b, a) ? 1 : 0)`;
-				case "SliceIsSorted":
-					return `${a[0]}.every((v, i, a) => i === 0 || ${a[1]}(a[i - 1], v))`;
-			}
-		}
-
-		// math.* — math functions
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "math"
-		) {
-			const a = expr.args.map((e) => this.genExpr(e));
-			switch (expr.func.field) {
-				case "Abs":
-					return `Math.abs(${a[0]})`;
-				case "Floor":
-					return `Math.floor(${a[0]})`;
-				case "Ceil":
-					return `Math.ceil(${a[0]})`;
-				case "Round":
-					return `Math.round(${a[0]})`;
-				case "Sqrt":
-					return `Math.sqrt(${a[0]})`;
-				case "Cbrt":
-					return `Math.cbrt(${a[0]})`;
-				case "Pow":
-					return `Math.pow(${a[0]}, ${a[1]})`;
-				case "Log":
-					return `Math.log(${a[0]})`;
-				case "Log2":
-					return `Math.log2(${a[0]})`;
-				case "Log10":
-					return `Math.log10(${a[0]})`;
-				case "Sin":
-					return `Math.sin(${a[0]})`;
-				case "Cos":
-					return `Math.cos(${a[0]})`;
-				case "Tan":
-					return `Math.tan(${a[0]})`;
-				case "Min":
-					return `Math.min(${a[0]}, ${a[1]})`;
-				case "Max":
-					return `Math.max(${a[0]}, ${a[1]})`;
-				case "Mod":
-					return `${a[0]} % ${a[1]}`;
-				case "Inf":
-					return `(${a[0]} >= 0 ? Infinity : -Infinity)`;
-				case "IsNaN":
-					return `Number.isNaN(${a[0]})`;
-				case "IsInf":
-					return `(${a[1]} > 0 ? ${a[0]} === Infinity : ${a[1]} < 0 ? ${a[0]} === -Infinity : !Number.isFinite(${a[0]}))`;
-				case "NaN":
-					return "NaN";
-			}
-		}
-
-		// unicode.* — rune/character classification
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "unicode"
-		) {
-			const a = expr.args.map((e) => this.genExpr(e));
-			switch (expr.func.field) {
-				case "IsLetter":
-					return `/\\p{L}/u.test(String.fromCodePoint(${a[0]}))`;
-				case "IsDigit":
-					return `/\\p{Nd}/u.test(String.fromCodePoint(${a[0]}))`;
-				case "IsSpace":
-					return `/\\s/.test(String.fromCodePoint(${a[0]}))`;
-				case "IsUpper":
-					return `((__c) => __c === __c.toUpperCase() && /\\p{L}/u.test(__c))(String.fromCodePoint(${a[0]}))`;
-				case "IsLower":
-					return `((__c) => __c === __c.toLowerCase() && /\\p{L}/u.test(__c))(String.fromCodePoint(${a[0]}))`;
-				case "IsPunct":
-					return `/\\p{P}/u.test(String.fromCodePoint(${a[0]}))`;
-				case "IsControl":
-					return `/\\p{Cc}/u.test(String.fromCodePoint(${a[0]}))`;
-				case "IsPrint":
-					return `!/\\p{Cc}/u.test(String.fromCodePoint(${a[0]}))`;
-				case "IsGraphic":
-					return `!/\\p{Cc}/u.test(String.fromCodePoint(${a[0]}))`;
-				case "ToUpper":
-					return `String.fromCodePoint(${a[0]}).toUpperCase().codePointAt(0)`;
-				case "ToLower":
-					return `String.fromCodePoint(${a[0]}).toLowerCase().codePointAt(0)`;
-			}
-		}
-
-		// os.* — process/environment access
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "os"
-		) {
-			const a = expr.args.map((e) => this.genExpr(e));
-			switch (expr.func.field) {
-				case "Exit":
-					return `process.exit(${a[0]})`;
-				case "Getenv":
-					return `(process.env[${a[0]}] ?? "")`;
-			}
+		// Standard library namespace dispatch — all follow the pattern:
+		// pkg.Func(args) → inline JS
+		if (expr.func.kind === "SelectorExpr" && expr.func.expr.kind === "Ident") {
+			const ns = expr.func.expr.name;
+			const fn = expr.func.field;
+			const result = this._genStdlibCall(ns, fn, expr);
+			if (result !== undefined) return result;
 		}
 
-		// errors.New — identity (errors are plain strings)
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "errors"
-		) {
-			const a = expr.args.map((e) => this.genExpr(e));
-			if (expr.func.field === "New") return a[0];
-		}
-
-		// time.* — partial JS-friendly time support
-		if (
-			expr.func.kind === "SelectorExpr" &&
-			expr.func.expr.kind === "Ident" &&
-			expr.func.expr.name === "time"
-		) {
-			const a = expr.args.map((e) => this.genExpr(e));
-			switch (expr.func.field) {
-				case "Now":
-					return "Date.now()";
-				case "Since":
-					return `(Date.now() - ${a[0]})`;
-				case "Sleep":
-					return `await new Promise(r => setTimeout(r, ${a[0]} / 1000000))`;
+		// strings.Builder / bytes.Buffer / regexp.Regexp method dispatch
+		if (expr.func.kind === "SelectorExpr") {
+			const recvType = expr.func.expr._type;
+			const recvName = recvType?.name ?? recvType?.base?.name;
+			if (recvName === "strings.Builder" || recvName === "bytes.Buffer") {
+				const typeName = recvType?.name ?? recvType?.base?.name;
+				return this._genBuilderCall(typeName, expr.func.field, expr);
+			}
+			if (recvName === "regexp.Regexp") {
+				return this._genRegexpMethodCall(expr.func.field, expr);
 			}
 		}
 
@@ -718,10 +605,18 @@ export const expressionGenMethods = {
 
 	// ── Helpers ───────────────────────────────────────────────────
 
+	_genComplexOperand(expr) {
+		if (isComplex(expr._type)) return this.genExpr(expr);
+		return `{ re: ${this.genExpr(expr)}, im: 0 }`;
+	},
+
 	getTypeName(typeNode) {
 		if (!typeNode) return null;
 		if (typeNode.kind === "TypeName") return typeNode.name;
+		if (typeNode.kind === "GenericTypeName") return typeNode.name;
 		if (typeNode.kind === "Ident") return typeNode.name;
+		if (typeNode.kind === "InstantiationExpr")
+			return this.getTypeName(typeNode.expr);
 		if (typeNode.kind === "SelectorExpr") return typeNode.field;
 		return null;
 	},
@@ -762,6 +657,9 @@ export const expressionGenMethods = {
 			case "byte":
 			case "rune":
 				return "0";
+			case "complex64":
+			case "complex128":
+				return "{ re: 0, im: 0 }";
 			case "string":
 				return '""';
 			case "bool":
@@ -777,6 +675,8 @@ export const expressionGenMethods = {
 			case "TypeName": {
 				const basic = this._zeroForBasicName(typeNode.name);
 				if (basic !== null) return basic;
+				if (typeNode.name === "strings.Builder") return '{ _buf: "" }';
+				if (typeNode.name === "bytes.Buffer") return "{ _buf: [] }";
 				if (this.structNames.has(typeNode.name))
 					return `new ${typeNode.name}()`;
 				return "null";
@@ -821,6 +721,8 @@ export const expressionGenMethods = {
 				return `{ ${fields} }`;
 			}
 			case "named":
+				if (t.name === "strings.Builder") return '{ _buf: "" }';
+				if (t.name === "bytes.Buffer") return "{ _buf: [] }";
 				if (this.structNames.has(t.name)) return `new ${t.name}()`;
 				return "null";
 			default:
@@ -856,7 +758,7 @@ export const expressionGenMethods = {
 				case "nil":
 					return `${val} === null`;
 				case "error":
-					return `typeof ${val} === "string"`;
+					return `(typeof ${val} === "object" && ${val} !== null && typeof ${val}.Error === "function")`;
 				default:
 					if (this.structNames.has(typeNode.name))
 						return `${val} instanceof ${typeNode.name}`;
@@ -891,6 +793,268 @@ export const expressionGenMethods = {
 		return base?.kind === "struct" || base?.kind === "array";
 	},
 
+	_genBuilderCall(typeName, method, expr) {
+		// Resolve the receiver — may be a direct var or a &var (pointer)
+		const recv = expr.func.expr;
+		const isPtr = recv._type?.kind === "pointer";
+		const base = isPtr ? `${this.genExpr(recv)}.value` : this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+
+		if (typeName === "strings.Builder") {
+			switch (method) {
+				case "WriteString":
+					return `(${base}._buf += ${args[0]}, [${args[0]}.length, null])`;
+				case "WriteByte":
+				case "WriteRune":
+					return `(${base}._buf += String.fromCodePoint(${args[0]}))`;
+				case "Write":
+					return `(${base}._buf += String.fromCharCode(...${args[0]}))`;
+				case "String":
+					return `${base}._buf`;
+				case "Len":
+					return `${base}._buf.length`;
+				case "Reset":
+					return `(${base}._buf = "")`;
+				case "Grow":
+					return "undefined";
+			}
+		}
+
+		if (typeName === "bytes.Buffer") {
+			switch (method) {
+				case "WriteString":
+					return `(${base}._buf.push(...new TextEncoder().encode(${args[0]})), [${args[0]}.length, null])`;
+				case "WriteByte":
+					return `${base}._buf.push(${args[0]})`;
+				case "Write":
+					return `(${base}._buf.push(...${args[0]}), [${args[0]}.length, null])`;
+				case "String":
+					return `new TextDecoder().decode(new Uint8Array(${base}._buf))`;
+				case "Bytes":
+					return `${base}._buf.slice()`;
+				case "Len":
+					return `${base}._buf.length`;
+				case "Reset":
+					return `(${base}._buf = [])`;
+				case "Grow":
+					return "undefined";
+			}
+		}
+
+		return undefined;
+	},
+
+	_genRegexp(fn, a) {
+		// Converts a Go regexp pattern string (which may contain inline flags like (?i))
+		// into a JS RegExp, extracting the flags into the second constructor argument.
+		const makeRegExp = (pat) =>
+			`((p) => { const m = /^\\(\\?([gimsuy]+)\\)/.exec(p); return m ? new RegExp(p.slice(m[0].length), m[1]) : new RegExp(p); })(${pat})`;
+		switch (fn) {
+			case "MustCompile":
+				return makeRegExp(a()[0]);
+			case "Compile":
+				return `[${makeRegExp(a()[0])}, null]`;
+			case "MatchString": {
+				const [pat, s] = a();
+				return `[new RegExp(${pat}).test(${s}), null]`;
+			}
+			case "QuoteMeta":
+				return `${a()[0]}.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&')`;
+		}
+		return undefined;
+	},
+
+	_genRegexpMethodCall(method, expr) {
+		const recv = expr.func.expr;
+		// *Regexp is a plain JS RegExp — no .value boxing needed
+		const re = this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+
+		switch (method) {
+			case "MatchString":
+				return `${re}.test(${args[0]})`;
+			case "FindString":
+				return `(${re}.exec(${args[0]})?.[0] ?? "")`;
+			case "FindStringIndex":
+				return `((m => m ? [m.index, m.index + m[0].length] : null)(${re}.exec(${args[0]})))`;
+			case "FindAllString":
+				return `[...${args[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${args[1]} < 0 ? undefined : ${args[1]}).map(m => m[0])`;
+			case "FindStringSubmatch":
+				return `[...(${re}.exec(${args[0]}) ?? [])]`;
+			case "FindAllStringSubmatch":
+				return `[...${args[0]}.matchAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"))].slice(0, ${args[1]} < 0 ? undefined : ${args[1]}).map(m => [...m])`;
+			case "ReplaceAllString":
+				return `${args[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${args[1]})`;
+			case "ReplaceAllLiteralString":
+				return `${args[0]}.replaceAll(new RegExp(${re}.source, ${re}.flags.includes("g") ? ${re}.flags : ${re}.flags + "g"), ${args[1]}.replace(/\\$/g, '$$$$'))`;
+			case "Split":
+				return `${args[0]}.split(${re}).slice(0, ${args[1]} < 0 ? undefined : ${args[1]})`;
+			case "String":
+				return `${re}.source`;
+		}
+		return undefined;
+	},
+
+	_genSlices(fn, a) {
+		switch (fn) {
+			case "Contains": {
+				const [s, v] = a();
+				return `${s}.includes(${v})`;
+			}
+			case "Index": {
+				const [s, v] = a();
+				return `${s}.indexOf(${v})`;
+			}
+			case "Equal": {
+				this._usesEqual = true;
+				const [a1, b1] = a();
+				return `__equal(${a1}, ${b1})`;
+			}
+			case "Compare": {
+				const [a1, b1] = a();
+				return `((a, b) => { for (let i = 0; i < a.length && i < b.length; i++) { if (a[i] < b[i]) return -1; if (a[i] > b[i]) return 1; } return a.length - b.length; })(${a1}, ${b1})`;
+			}
+			case "Sort": {
+				const [s] = a();
+				return `${s}.sort((a, b) => a < b ? -1 : a > b ? 1 : 0)`;
+			}
+			case "SortFunc": {
+				const [s, cmp] = a();
+				return `${s}.sort(${cmp})`;
+			}
+			case "SortStableFunc": {
+				const [s, cmp] = a();
+				return `${s}.sort(${cmp})`;
+			}
+			case "IsSorted": {
+				const [s] = a();
+				return `((s) => { for (let i = 1; i < s.length; i++) { if (s[i] < s[i-1]) return false; } return true; })(${s})`;
+			}
+			case "IsSortedFunc": {
+				const [s, cmp] = a();
+				return `((s, f) => { for (let i = 1; i < s.length; i++) { if (f(s[i], s[i-1]) < 0) return false; } return true; })(${s}, ${cmp})`;
+			}
+			case "Reverse": {
+				const [s] = a();
+				return `${s}.reverse()`;
+			}
+			case "Max": {
+				const [s] = a();
+				return `Math.max(...${s})`;
+			}
+			case "Min": {
+				const [s] = a();
+				return `Math.min(...${s})`;
+			}
+			case "MaxFunc": {
+				const [s, cmp] = a();
+				return `((s, f) => s.reduce((m, x) => f(x, m) > 0 ? x : m))(${s}, ${cmp})`;
+			}
+			case "MinFunc": {
+				const [s, cmp] = a();
+				return `((s, f) => s.reduce((m, x) => f(x, m) < 0 ? x : m))(${s}, ${cmp})`;
+			}
+			case "Clone": {
+				const [s] = a();
+				return `${s}.slice()`;
+			}
+			case "Compact": {
+				const [s] = a();
+				return `((s) => s.filter((v, i) => i === 0 || v !== s[i-1]))(${s})`;
+			}
+			case "CompactFunc": {
+				const [s, eq] = a();
+				return `((s, f) => s.filter((v, i) => i === 0 || !f(v, s[i-1])))(${s}, ${eq})`;
+			}
+			case "Concat": {
+				const args = a();
+				return `[].concat(${args.join(", ")})`;
+			}
+			case "Delete": {
+				const [s, i, j] = a();
+				return `[...${s}.slice(0, ${i}), ...${s}.slice(${j})]`;
+			}
+			case "DeleteFunc": {
+				const [s, fn2] = a();
+				return `${s}.filter((v) => !${fn2}(v))`;
+			}
+			case "Insert": {
+				const args = a();
+				const s = args[0];
+				const i = args[1];
+				const vs = args.slice(2);
+				return `[...${s}.slice(0, ${i}), ${vs.join(", ")}, ...${s}.slice(${i})]`;
+			}
+			case "Replace": {
+				const args = a();
+				const s = args[0];
+				const i = args[1];
+				const j = args[2];
+				const vs = args.slice(3);
+				return `[...${s}.slice(0, ${i}), ${vs.join(", ")}, ...${s}.slice(${j})]`;
+			}
+			case "Grow":
+			case "Clip": {
+				const [s] = a();
+				return `${s}.slice()`;
+			}
+		}
+		return undefined;
+	},
+
+	_genHtml(fn, a) {
+		switch (fn) {
+			case "EscapeString": {
+				const [s] = a();
+				return `${s}.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&#34;").replace(/'/g,"&#39;")`;
+			}
+			case "UnescapeString": {
+				const [s] = a();
+				return `${s}.replace(/&#39;/g,"'").replace(/&#34;/g,'"').replace(/&gt;/g,">").replace(/&lt;/g,"<").replace(/&amp;/g,"&")`;
+			}
+		}
+		return undefined;
+	},
+
+	_genMaps(fn, a) {
+		switch (fn) {
+			case "Keys": {
+				const [m] = a();
+				return `Object.keys(${m})`;
+			}
+			case "Values": {
+				const [m] = a();
+				return `Object.values(${m})`;
+			}
+			case "Clone": {
+				const [m] = a();
+				return `({...${m}})`;
+			}
+			case "Copy": {
+				const [dst, src] = a();
+				return `Object.assign(${dst}, ${src})`;
+			}
+			case "Equal": {
+				this._usesEqual = true;
+				const [a1, b1] = a();
+				return `__equal(${a1}, ${b1})`;
+			}
+			case "EqualFunc": {
+				const [m1, m2, eq] = a();
+				return `((a, b, f) => { const ka = Object.keys(a); if (ka.length !== Object.keys(b).length) return false; return ka.every(k => k in b && f(a[k], b[k])); })(${m1}, ${m2}, ${eq})`;
+			}
+			case "Delete": {
+				const [m, k] = a();
+				return `(delete ${m}[${k}], undefined)`;
+			}
+			case "DeleteFunc": {
+				const [m, fn2] = a();
+				return `Object.keys(${m}).forEach(k => { if (${fn2}(k, ${m}[k])) delete ${m}[k]; })`;
+			}
+		}
+		return undefined;
+	},
+
 	typeComment(typeNode) {
 		if (!typeNode) return "unknown";
 		switch (typeNode.kind) {
@@ -904,4 +1068,365 @@ export const expressionGenMethods = {
 				return typeNode.kind;
 		}
 	},
+
+	// Dispatch table for stdlib namespace calls (pkg.Func → inline JS).
+	// Returns the generated JS string, or undefined if not handled.
+	_genStdlibCall(ns, fn, expr) {
+		const a = () => expr.args.map((e) => this.genExpr(e));
+		switch (ns) {
+			case "fmt":
+				return this._genFmt(fn, a, expr);
+			case "strings":
+				return this._genStrings(fn, a);
+			case "bytes":
+				return this._genBytes(fn, a);
+			case "strconv":
+				return this._genStrconv(fn, a);
+			case "sort":
+				return this._genSort(fn, a);
+			case "math":
+				return this._genMath(fn, a);
+			case "unicode":
+				return this._genUnicode(fn, a);
+			case "os":
+				return this._genOs(fn, a);
+			case "errors":
+				return this._genErrors(fn, a);
+			case "time":
+				return this._genTime(fn, a);
+			case "regexp":
+				return this._genRegexp(fn, a);
+			case "slices":
+				return this._genSlices(fn, a);
+			case "maps":
+				return this._genMaps(fn, a);
+			case "html":
+				return this._genHtml(fn, a);
+			default:
+				return undefined;
+		}
+	},
+
+	_genFmt(fn, _a, expr) {
+		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
+		switch (fn) {
+			case "Sprintf":
+				this._usesSprintf = true;
+				return `__sprintf(${fmtArgs})`;
+			case "Errorf": {
+				this._usesSprintf = true;
+				this._usesError = true;
+				const fmtStr = expr.args[0];
+				if (fmtStr?.kind === "BasicLit" && fmtStr.value?.includes("%w")) {
+					const lastArg = this.genExpr(expr.args[expr.args.length - 1]);
+					return `__error(__sprintf(${fmtArgs}), ${lastArg})`;
+				}
+				return `__error(__sprintf(${fmtArgs}))`;
+			}
+			case "Printf":
+			case "Print":
+				this._usesSprintf = true;
+				return `process?.stdout?.write(__sprintf(${fmtArgs}))`;
+			case "Println":
+				this._usesSprintf = true;
+				return `console.log(__sprintf(${fmtArgs}))`;
+			case "Fprintf":
+			case "Fprintln":
+			case "Fprint": {
+				this._usesSprintf = true;
+				const writerArg = expr.args[0];
+				const rest = expr.args.slice(1);
+				const restJs = rest.map((e) => this.genExpr(e)).join(", ");
+				// Resolve the writer to its underlying buffer expression
+				const writerType = writerArg._type;
+				const targetTypeName =
+					writerType?.name ??
+					(writerType?.kind === "pointer" ? writerType.base?.name : null);
+				let buf;
+				if (targetTypeName === "strings.Builder") {
+					const w = this.genExpr(writerArg);
+					buf =
+						writerType?.kind === "pointer" ? `${w}.value._buf` : `${w}._buf`;
+				} else if (targetTypeName === "bytes.Buffer") {
+					const w = this.genExpr(writerArg);
+					const base = writerType?.kind === "pointer" ? `${w}.value` : w;
+					buf = null;
+					if (fn === "Fprintf") {
+						return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, __sprintf(${restJs}))`;
+					}
+					const valJs =
+						fn === "Fprintln"
+							? `__sprintf("%v\\n", ${restJs})`
+							: `__sprintf("%v", ${restJs})`;
+					return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${valJs})`;
+				} else {
+					// Generic io.Writer fallback — call .WriteString if available
+					const w = this.genExpr(writerArg);
+					const formatted =
+						fn === "Fprintf"
+							? `__sprintf(${restJs})`
+							: fn === "Fprintln"
+								? `__sprintf("%v\\n", ${restJs})`
+								: `__sprintf("%v", ${restJs})`;
+					return `${w}.WriteString(${formatted})`;
+				}
+				// strings.Builder path
+				if (fn === "Fprintf") return `(${buf} += __sprintf(${restJs}))`;
+				if (fn === "Fprintln")
+					return `(${buf} += __sprintf("%v\\n", ${restJs}))`;
+				return `(${buf} += __sprintf("%v", ${restJs}))`;
+			}
+			default:
+				return undefined;
+		}
+	},
+
+	_genStrings(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "Contains":
+				return `${args[0]}.includes(${args[1]})`;
+			case "HasPrefix":
+				return `${args[0]}.startsWith(${args[1]})`;
+			case "HasSuffix":
+				return `${args[0]}.endsWith(${args[1]})`;
+			case "Index":
+				return `${args[0]}.indexOf(${args[1]})`;
+			case "LastIndex":
+				return `${args[0]}.lastIndexOf(${args[1]})`;
+			case "Count":
+				return `((s, sep) => sep === "" ? s.length + 1 : s.split(sep).length - 1)(${args[0]}, ${args[1]})`;
+			case "Repeat":
+				return `${args[0]}.repeat(${args[1]})`;
+			case "Replace":
+				return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+			case "ReplaceAll":
+				return `${args[0]}.replaceAll(${args[1]}, ${args[2]})`;
+			case "ToUpper":
+				return `${args[0]}.toUpperCase()`;
+			case "ToLower":
+				return `${args[0]}.toLowerCase()`;
+			case "TrimSpace":
+				return `${args[0]}.trim()`;
+			case "Trim":
+				return `${args[0]}.replace(new RegExp(\`^[\${${args[1]}}]+|[\${${args[1]}}]+$\`, "g"), "")`;
+			case "TrimPrefix":
+				return `((s, pre) => s.startsWith(pre) ? s.slice(pre.length) : s)(${args[0]}, ${args[1]})`;
+			case "TrimSuffix":
+				return `((s, suf) => !suf.length || !s.endsWith(suf) ? s : s.slice(0, -suf.length))(${args[0]}, ${args[1]})`;
+			case "TrimLeft":
+				return `${args[0]}.replace(new RegExp(\`^[\${${args[1]}}]+\`), "")`;
+			case "TrimRight":
+				return `${args[0]}.replace(new RegExp(\`[\${${args[1]}}]+$\`), "")`;
+			case "Split":
+				return `${args[0]}.split(${args[1]})`;
+			case "Join":
+				return `${args[0]}.join(${args[1]})`;
+			case "EqualFold":
+				return `${args[0]}.toLowerCase() === ${args[1]}.toLowerCase()`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genBytes(fn, a) {
+		const __bs = `(b => String.fromCharCode(...b))`;
+		const __sb = `(s => [...s].map(c => c.charCodeAt(0)))`;
+		const args = a();
+		switch (fn) {
+			case "Contains":
+				return `${__bs}(${args[0]}).includes(${__bs}(${args[1]}))`;
+			case "HasPrefix":
+				return `((b, p) => { for (let i = 0; i < p.length; i++) if (b[i] !== p[i]) return false; return b.length >= p.length; })(${args[0]}, ${args[1]})`;
+			case "HasSuffix":
+				return `((b, s) => { const off = b.length - s.length; if (off < 0) return false; for (let i = 0; i < s.length; i++) if (b[off + i] !== s[i]) return false; return true; })(${args[0]}, ${args[1]})`;
+			case "Index":
+				return `${__bs}(${args[0]}).indexOf(${__bs}(${args[1]}))`;
+			case "Count":
+				return `((b, sep) => sep.length === 0 ? b.length + 1 : ${__bs}(b).split(${__bs}(sep)).length - 1)(${args[0]}, ${args[1]})`;
+			case "Repeat":
+				return `${__sb}(${__bs}(${args[0]}).repeat(${args[1]}))`;
+			case "Replace":
+				return `((b, o, n, cnt) => { let s = ${__bs}(b), os = ${__bs}(o), ns = ${__bs}(n); if (cnt < 0) return ${__sb}(s.replaceAll(os, ns)); for (let i = 0; i < cnt; i++) s = s.replace(os, ns); return ${__sb}(s); })(${args[0]}, ${args[1]}, ${args[2]}, ${args[3]})`;
+			case "ToUpper":
+				return `${__sb}(${__bs}(${args[0]}).toUpperCase())`;
+			case "ToLower":
+				return `${__sb}(${__bs}(${args[0]}).toLowerCase())`;
+			case "TrimSpace":
+				return `${__sb}(${__bs}(${args[0]}).trim())`;
+			case "Trim":
+				return `${__sb}(${__bs}(${args[0]}).replace(new RegExp(\`^[\${${args[1]}}]+|[\${${args[1]}}]+$\`, "g"), ""))`;
+			case "Equal":
+				return `((a, b) => { if (a.length !== b.length) return false; for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false; return true; })(${args[0]}, ${args[1]})`;
+			case "Split":
+				return `${__bs}(${args[0]}).split(${__bs}(${args[1]})).map(p => ${__sb}(p))`;
+			case "Join":
+				return `${__sb}(${args[0]}.map(p => ${__bs}(p)).join(${__bs}(${args[1]})))`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genStrconv(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "Itoa":
+				return `String(${args[0]})`;
+			case "Atoi":
+				return `(Number.isNaN(Number(${args[0]})) ? [0, "invalid syntax"] : [Number(${args[0]}) | 0, null])`;
+			case "FormatBool":
+				return `String(${args[0]})`;
+			case "FormatInt":
+				return `(${args[0]}).toString(${args[1]})`;
+			case "FormatFloat":
+				return `String(${args[0]})`;
+			case "ParseFloat":
+				return `(Number.isNaN(Number(${args[0]})) ? [0, "invalid syntax"] : [Number(${args[0]}), null])`;
+			case "ParseInt":
+				return `(Number.isNaN(parseInt(${args[0]}, ${args[1]} || 10)) ? [0, "invalid syntax"] : [parseInt(${args[0]}, ${args[1]} || 10), null])`;
+			case "ParseBool":
+				return `(${args[0]} === "true" || ${args[0]} === "1" ? [true, null] : ${args[0]} === "false" || ${args[0]} === "0" ? [false, null] : [false, "invalid syntax"])`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genSort(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "Ints":
+			case "Float64s":
+				return `${args[0]}.sort((a, b) => a - b)`;
+			case "Strings":
+				return `${args[0]}.sort()`;
+			case "Slice":
+			case "SliceStable":
+				return `${args[0]}.sort((a, b) => ${args[1]}(a, b) ? -1 : ${args[1]}(b, a) ? 1 : 0)`;
+			case "SliceIsSorted":
+				return `${args[0]}.every((v, i, a) => i === 0 || ${args[1]}(a[i - 1], v))`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genMath(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "Abs":
+				return `Math.abs(${args[0]})`;
+			case "Floor":
+				return `Math.floor(${args[0]})`;
+			case "Ceil":
+				return `Math.ceil(${args[0]})`;
+			case "Round":
+				return `Math.round(${args[0]})`;
+			case "Sqrt":
+				return `Math.sqrt(${args[0]})`;
+			case "Cbrt":
+				return `Math.cbrt(${args[0]})`;
+			case "Pow":
+				return `Math.pow(${args[0]}, ${args[1]})`;
+			case "Log":
+				return `Math.log(${args[0]})`;
+			case "Log2":
+				return `Math.log2(${args[0]})`;
+			case "Log10":
+				return `Math.log10(${args[0]})`;
+			case "Sin":
+				return `Math.sin(${args[0]})`;
+			case "Cos":
+				return `Math.cos(${args[0]})`;
+			case "Tan":
+				return `Math.tan(${args[0]})`;
+			case "Min":
+				return `Math.min(${args[0]}, ${args[1]})`;
+			case "Max":
+				return `Math.max(${args[0]}, ${args[1]})`;
+			case "Mod":
+				return `${args[0]} % ${args[1]}`;
+			case "Inf":
+				return `(${args[0]} >= 0 ? Infinity : -Infinity)`;
+			case "IsNaN":
+				return `Number.isNaN(${args[0]})`;
+			case "IsInf":
+				return `(${args[1]} > 0 ? ${args[0]} === Infinity : ${args[1]} < 0 ? ${args[0]} === -Infinity : !Number.isFinite(${args[0]}))`;
+			case "NaN":
+				return "NaN";
+			default:
+				return undefined;
+		}
+	},
+
+	_genUnicode(fn, a) {
+		const args = a();
+		const cp = `String.fromCodePoint(${args[0]})`;
+		switch (fn) {
+			case "IsLetter":
+				return `/\\p{L}/u.test(${cp})`;
+			case "IsDigit":
+				return `/\\p{Nd}/u.test(${cp})`;
+			case "IsSpace":
+				return `/\\s/.test(${cp})`;
+			case "IsUpper":
+				return `((__c) => __c === __c.toUpperCase() && /\\p{L}/u.test(__c))(${cp})`;
+			case "IsLower":
+				return `((__c) => __c === __c.toLowerCase() && /\\p{L}/u.test(__c))(${cp})`;
+			case "IsPunct":
+				return `/\\p{P}/u.test(${cp})`;
+			case "IsControl":
+				return `/\\p{Cc}/u.test(${cp})`;
+			case "IsPrint":
+				return `!/\\p{Cc}/u.test(${cp})`;
+			case "IsGraphic":
+				return `!/\\p{Cc}/u.test(${cp})`;
+			case "ToUpper":
+				return `${cp}.toUpperCase().codePointAt(0)`;
+			case "ToLower":
+				return `${cp}.toLowerCase().codePointAt(0)`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genOs(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "Exit":
+				return `process.exit(${args[0]})`;
+			case "Getenv":
+				return `(process.env[${args[0]}] ?? "")`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genErrors(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "New":
+				this._usesError = true;
+				return `__error(${args[0]})`;
+			case "Is":
+				this._usesErrorIs = true;
+				return `__errorIs(${args[0]}, ${args[1]})`;
+			case "Unwrap":
+				return `(${args[0]}?._cause ?? null)`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genTime(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "Now":
+				return "Date.now()";
+			case "Since":
+				return `(Date.now() - ${args[0]})`;
+			case "Sleep":
+				return `await new Promise(r => setTimeout(r, ${args[0]} / 1000000))`;
+			default:
+				return undefined;
+		}
+	},
 };