gofront 0.0.3 → 0.0.5

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
@@ -48,6 +103,15 @@ export const expressionGenMethods = {
 				if (expr.op === "&^") {
 					return `${l} & ~${r}`;
 				}
+				// Struct/array equality: use __equal for value comparison
+				if (expr.op === "==" || expr.op === "!=") {
+					const lt = expr.left._type;
+					if (this._isStructOrArrayType(lt)) {
+						this._usesEqual = true;
+						const cmp = `__equal(${l}, ${r})`;
+						return expr.op === "==" ? cmp : `!${cmp}`;
+					}
+				}
 				// Go == and != are strict — map to JS === / !==
 				const op =
 					expr.op === "==" ? "===" : expr.op === "!=" ? "!==" : expr.op;
@@ -57,7 +121,15 @@ 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) {
+					const method = expr.field;
+					return `((recv, ...args) => recv.${method}(...args))`;
+				}
 				// math constants
 				if (expr.expr.kind === "Ident" && expr.expr.name === "math") {
 					switch (expr.field) {
@@ -75,6 +147,13 @@ export const expressionGenMethods = {
 							return "Number.MIN_SAFE_INTEGER";
 					}
 				}
+				// os constants/vars
+				if (expr.expr.kind === "Ident" && expr.expr.name === "os") {
+					switch (expr.field) {
+						case "Args":
+							return "process.argv";
+					}
+				}
 				// time constants (nanosecond durations)
 				if (expr.expr.kind === "Ident" && expr.expr.name === "time") {
 					switch (expr.field) {
@@ -91,11 +170,17 @@ 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") {
-					return `${base}.value.${expr.field}`;
+					const sel = `${base}.value.${expr.field}`;
+					if (expr._isMethodValue && !expr._callee)
+						return `${sel}.bind(${base}.value)`;
+					return sel;
 				}
-				return `${base}.${expr.field}`;
+				const sel = `${base}.${expr.field}`;
+				// Method used as value (not called) — bind the receiver
+				if (expr._isMethodValue && !expr._callee) return `${sel}.bind(${base})`;
+				return sel;
 			}
 
 			case "IndexExpr": {
@@ -110,6 +195,14 @@ export const expressionGenMethods = {
 					}
 					return `(${base}[${idx}] ?? ${zero})`;
 				}
+				// String indexing returns a byte (charCodeAt), not a JS character
+				const exprType = expr.expr._type;
+				const isStr =
+					(exprType?.kind === "basic" && exprType.name === "string") ||
+					(exprType?.kind === "untyped" && exprType.base === "string");
+				if (isStr && !expr._lvalue) {
+					return `${base}.charCodeAt(${idx})`;
+				}
 				return `${base}[${idx}]`;
 			}
 
@@ -129,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)}}`;
 			}
 
@@ -140,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;
@@ -162,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"
@@ -169,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":
@@ -209,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);
@@ -250,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(", ");
@@ -274,225 +408,50 @@ 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":
-					this._usesSprintf = true;
-					return `__sprintf(${fmtArgs})`;
-				case "Errorf":
-					this._usesSprintf = true;
-					return `__sprintf(${fmtArgs})`;
-				case "Printf":
-					this._usesSprintf = true;
-					return `process?.stdout?.write(__sprintf(${fmtArgs}))`;
-				case "Println":
-					this._usesSprintf = true;
-					return `console.log(__sprintf(${fmtArgs}))`;
-				case "Print":
-					this._usesSprintf = true;
-					return `process?.stdout?.write(__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";
-			}
-		}
-
-		// 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))`;
-			}
+		// 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;
 		}
 
+		// Mark the callee so SelectorExpr knows it's being called, not used as a value
+		expr.func._callee = true;
 		const rawFn = this.genExpr(expr.func);
 		// Wrap function literals in parens so `function(){}()` → `(function(){})()`
 		const fn = expr.func.kind === "FuncLit" ? `(${rawFn})` : rawFn;
+		// Multi-value forwarding: f(g()) where g() returns multiple values → f(...g())
+		if (expr._multiForward) {
+			return `${fn}(...${this.genExpr(expr.args[0])})`;
+		}
 		const args = expr.args
 			.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
 			.join(", ");
@@ -537,34 +496,40 @@ export const expressionGenMethods = {
 		return "{}";
 	},
 
-	// Render KeyValueExpr elements as a JS field list string.
-	// Handles embedded-spread (_isEmbedInit) and plain key: value pairs.
+	// Render struct elements as a JS field list string.
+	// Handles positional (_positionalField), embedded-spread (_isEmbedInit), and keyed (KeyValueExpr).
 	_genStructFields(elems) {
 		return elems
-			.filter((e) => e.kind === "KeyValueExpr")
-			.map((e) =>
-				e._isEmbedInit
-					? `...${this.genExpr(e.value)}`
-					: `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`,
-			)
+			.map((e) => {
+				if (e._positionalField) {
+					return `${e._positionalField}: ${this.genExpr(e)}`;
+				}
+				if (e.kind !== "KeyValueExpr") return null;
+				if (e._isEmbedInit) return `...${this.genExpr(e.value)}`;
+				return `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`;
+			})
+			.filter((s) => s !== null)
 			.join(", ");
 	},
 
 	genCompositeLit(expr) {
 		const t = expr.typeExpr;
 
-		// Implicit composite literal: {X: 1} inside a slice/map — type inferred from context
+		// Implicit composite literal: {X: 1} or {1, 2} inside a slice/map — type inferred from context
 		if (t === null) {
-			if (expr.elems.length > 0 && expr.elems[0]?.kind === "KeyValueExpr") {
-				const typeName = expr._type?.name ?? expr._type?.underlying?.name;
+			const typeName = expr._type?.name ?? expr._type?.underlying?.name;
+			const hasPositional = expr.elems.some((e) => e._positionalField);
+			const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
+			if (hasPositional || hasKeyed) {
 				if (typeName && this.structNames.has(typeName)) {
 					return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
 				}
 				const fields = expr.elems
-					.map(
-						(e) =>
-							`${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`,
-					)
+					.map((e) => {
+						if (e._positionalField)
+							return `${e._positionalField}: ${this.genExpr(e)}`;
+						return `${e.key.name ?? this.genExpr(e.key)}: ${this.genExpr(e.value)}`;
+					})
 					.join(", ");
 				return `{ ${fields} }`;
 			}
@@ -573,11 +538,18 @@ export const expressionGenMethods = {
 
 		const typeName = this.getTypeName(t);
 
-		// Struct: new Foo({ X: 1, Y: 2 })
+		// Struct: new Foo({ X: 1, Y: 2 }) — keyed or positional
 		if (typeName && this.structNames.has(typeName)) {
 			return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
 		}
 
+		// Fallback: named type that's not a struct but has positional elements → treat as struct
+		if (expr.elems.some((e) => e._positionalField)) {
+			if (typeName) {
+				return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
+			}
+		}
+
 		// Slice/array: [1, 2, 3]
 		if (t?.kind === "SliceType" || t?.kind === "ArrayType") {
 			const elems = expr.elems
@@ -620,10 +592,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;
 	},
@@ -664,6 +644,9 @@ export const expressionGenMethods = {
 			case "byte":
 			case "rune":
 				return "0";
+			case "complex64":
+			case "complex128":
+				return "{ re: 0, im: 0 }";
 			case "string":
 				return '""';
 			case "bool":
@@ -710,10 +693,8 @@ export const expressionGenMethods = {
 	zeroValueForType(t) {
 		if (!t) return "null";
 		switch (t.kind) {
-			case "basic": {
-				const basic = this._zeroForBasicName(t.name);
-				return basic !== null ? basic : "null";
-			}
+			case "basic":
+				return this._zeroForBasicName(t.name) ?? "null";
 			case "slice":
 				return "null";
 			case "map":
@@ -760,7 +741,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}`;
@@ -788,6 +769,13 @@ export const expressionGenMethods = {
 		return "null";
 	},
 
+	// Returns true if the type is a struct or array (uses value comparison with __equal).
+	_isStructOrArrayType(t) {
+		if (!t) return false;
+		const base = t.kind === "named" ? t.underlying : t;
+		return base?.kind === "struct" || base?.kind === "array";
+	},
+
 	typeComment(typeNode) {
 		if (!typeNode) return "unknown";
 		switch (typeNode.kind) {
@@ -801,4 +789,311 @@ 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);
+			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}))`;
+			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 `${args[0]}.split(${args[1]}).length - 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 `(${args[0]}.startsWith(${args[1]}) ? ${args[0]}.slice(${args[1]}.length) : ${args[0]})`;
+			case "TrimSuffix":
+				return `(${args[0]}.endsWith(${args[1]}) ? ${args[0]}.slice(0, -${args[1]}.length) : ${args[0]})`;
+			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 `${__bs}(${args[0]}).split(${__bs}(${args[1]})).length - 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;
+		}
+	},
 };