gofront 1.5.1 → 1.6.0

package/src/backend/js/statements.js

@@ -31,27 +31,35 @@ export const statementGenMethods = {
 	},
 
 	// Shared helper for comma-ok map index in both DefineStmt and AssignStmt.
-	// isDefine=true  → emit `let v = m[k]; let ok = k in m;`
-	// isDefine=false → emit `v = k in m ? m[k] : zero; ok = k in m;`
 	_genCommaOkMapIndex(stmt, rhsNode, isDefine) {
 		const mapExpr = this.genExpr(rhsNode.expr);
 		const keyExpr = this.genExpr(rhsNode.index);
 		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
 		const decl = isDefine ? "let " : "";
-		if (vName !== "_") {
-			if (isDefine) {
+		if (isDefine && !this.strict) {
+			if (vName !== "_") {
 				this.line(`let ${vName} = ${mapExpr}[${keyExpr}];`);
-			} else {
-				const zero = rhsNode._mapValueType
-					? this.zeroValueForType(rhsNode._mapValueType)
-					: "undefined";
-				this.line(
-					`${vName} = (${keyExpr}) in ${mapExpr} ? ${mapExpr}[${keyExpr}] : ${zero};`,
-				);
 			}
+			if (okName !== "_") {
+				this.line(`let ${okName} = (${keyExpr}) in ${mapExpr};`);
+			}
+			return;
+		}
+		const zero = rhsNode._mapValueType
+			? this.zeroValueForType(rhsNode._mapValueType)
+			: "undefined";
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const mTmp = `__m${this._tmpCounter}`;
+		const kTmp = `__k${this._tmpCounter}`;
+		this.line(`const ${mTmp} = ${mapExpr}, ${kTmp} = ${keyExpr};`);
+		if (vName !== "_") {
+			this.line(
+				`${decl}${vName} = (${mTmp} && (${kTmp} in ${mTmp})) ? ${mTmp}[${kTmp}] : ${zero};`,
+			);
+		}
+		if (okName !== "_") {
+			this.line(`${decl}${okName} = Boolean(${mTmp} && (${kTmp} in ${mTmp}));`);
 		}
-		if (okName !== "_")
-			this.line(`${decl}${okName} = (${keyExpr}) in ${mapExpr};`);
 	},
 
 	genStmt(stmt) {
@@ -63,6 +71,33 @@ export const statementGenMethods = {
 				this.genTypeDeclWithMethods(stmt, []);
 				break;
 			case "IncDecStmt": {
+				if (stmt.expr.kind === "IndexExpr" && stmt.expr._mapValueType) {
+					const zero = this.zeroValueForType(stmt.expr._mapValueType);
+					const wrapField = this._namedWrapperField(
+						stmt.expr.expr._type,
+						stmt.expr.expr,
+					);
+					const base = wrapField
+						? `${this.genExpr(stmt.expr.expr)}.${wrapField}`
+						: this.genExpr(stmt.expr.expr);
+					const idx = this.genExpr(stmt.expr.index);
+					const op = stmt.op === "++" ? "+" : "-";
+					if (
+						this._hasCallExpr(stmt.expr.expr) ||
+						this._hasCallExpr(stmt.expr.index)
+					) {
+						this.line(
+							`((__m, __k) => { __m[__k] = (__m[__k] ?? ${zero}) ${op} 1; })(${base}, ${idx});`,
+							srcLine,
+						);
+					} else {
+						this.line(
+							`${base}[${idx}] = (${base}[${idx}] ?? ${zero}) ${op} 1;`,
+							srcLine,
+						);
+					}
+					break;
+				}
 				if (
 					this.strict &&
 					this._genStrictCompound(
@@ -266,6 +301,35 @@ export const statementGenMethods = {
 		if (active.length === 0) {
 			if (rhs.length > 0) this.line(`${rhs[0]};`);
 		} else if (lhs.length === 1) {
+			if (
+				stmt.op !== "=" &&
+				stmt.lhs[0].kind === "IndexExpr" &&
+				stmt.lhs[0]._mapValueType
+			) {
+				const zero = this.zeroValueForType(stmt.lhs[0]._mapValueType);
+				const wrapField = this._namedWrapperField(
+					stmt.lhs[0].expr._type,
+					stmt.lhs[0].expr,
+				);
+				const base = wrapField
+					? `${this.genExpr(stmt.lhs[0].expr)}.${wrapField}`
+					: this.genExpr(stmt.lhs[0].expr);
+				const idx = this.genExpr(stmt.lhs[0].index);
+				const binOp = stmt.op.slice(0, -1);
+				if (
+					this._hasCallExpr(stmt.lhs[0].expr) ||
+					this._hasCallExpr(stmt.lhs[0].index)
+				) {
+					this.line(
+						`((__m, __k) => { __m[__k] = (__m[__k] ?? ${zero}) ${binOp} (${active[0].r}); })(${base}, ${idx});`,
+					);
+				} else {
+					this.line(
+						`${base}[${idx}] = (${base}[${idx}] ?? ${zero}) ${binOp} (${active[0].r});`,
+					);
+				}
+				return;
+			}
 			if (
 				this.strict &&
 				stmt.op !== "=" &&
@@ -333,11 +397,11 @@ export const statementGenMethods = {
 				result = `{ re: ${lhsStr}.re - ${rhsExpr}.re, im: ${lhsStr}.im - ${rhsExpr}.im }`;
 				break;
 			case "*":
-				this._usesCmul = true;
+				this.useHelper("cmul");
 				result = `__cmul(${lhsStr}, ${rhsExpr})`;
 				break;
 			case "/":
-				this._usesCdiv = true;
+				this.useHelper("cdiv");
 				result = `__cdiv(${lhsStr}, ${rhsExpr})`;
 				break;
 			default:
@@ -379,6 +443,22 @@ export const statementGenMethods = {
 			} else {
 				this.line("return;");
 			}
+		} else if (this.namedReturnVars?.length > 0) {
+			const vars = this.namedReturnVars;
+			if (stmt.values.length === 1 && vars.length === 1) {
+				this.line(`${vars[0]} = ${this._genReturnValue(stmt.values[0])};`);
+			} else if (stmt.values.length === 1 && vars.length > 1) {
+				const val = this._genReturnValue(stmt.values[0]);
+				this.line(`[${vars.join(", ")}] = ${val};`);
+			} else if (stmt.values.length > 1 && stmt.values.length === vars.length) {
+				const temps = stmt.values.map((v) => this._genReturnValue(v));
+				this.line(`[${vars.join(", ")}] = [${temps.join(", ")}];`);
+			}
+			this.line(
+				vars.length === 1
+					? `return ${vars[0]};`
+					: `return [${vars.join(", ")}];`,
+			);
 		} else if (stmt.values.length === 1) {
 			this.line(`return ${this._genReturnValue(stmt.values[0])};`);
 		} else {
@@ -662,7 +742,7 @@ export const statementGenMethods = {
 			if (lhs.length === 1) return `Array.from(${iteree}).keys()`;
 			return `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;
 		}
-		this._usesSliceGuard = true;
+		this.useHelper("sliceGuard");
 		if (lhs.length === 1) return `__s(${iteree}).keys()`;
 		return `__s(${iteree}).entries()`;
 	},

package/src/backend/js/stdlib/errors.js

@@ -7,11 +7,11 @@ export const errorsMethods = {
 	_genErrors(fn, a) {
 		const args = a();
 		if (fn === "New") {
-			this._usesError = true;
+			this.useHelper("error");
 			return `__error(${args[0]})`;
 		}
 		if (fn === "Is") {
-			this._usesErrorIs = true;
+			this.useHelper("errorIs");
 			return `__errorIs(${args[0]}, ${args[1]})`;
 		}
 		if (fn === "Unwrap") return `(${args[0]}?._cause ?? null)`;

package/src/backend/js/stdlib/fmt.js

@@ -15,11 +15,11 @@ export const fmtMethods = {
 		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
 		switch (fn) {
 			case "Sprintf":
-				this._usesSprintf = true;
+				this.useHelper("sprintf");
 				return `__sprintf(${fmtArgs})`;
 			case "Errorf": {
-				this._usesSprintf = true;
-				this._usesError = true;
+				this.useHelper("sprintf");
+				this.useHelper("error");
 				const fmtStr = expr.args[0];
 				if (fmtStr?.kind === "BasicLit" && fmtStr.value?.includes("%w")) {
 					const lastArg = this.genExpr(expr.args[expr.args.length - 1]);
@@ -28,12 +28,15 @@ export const fmtMethods = {
 				return `__error(__sprintf(${fmtArgs}))`;
 			}
 			case "Printf":
+				this.useHelper("sprintf");
+				return this._genStdoutWrite(`__sprintf(${fmtArgs})`);
 			case "Print":
-				this._usesSprintf = true;
-				return `process?.stdout?.write(__sprintf(${fmtArgs}))`;
+				this.useHelper("sprintf");
+				return this._genStdoutWrite(this._genPrintOperands(expr, "", ""));
 			case "Println":
-				this._usesSprintf = true;
-				return `console.log(__sprintf(${fmtArgs}))`;
+				this.useHelper("sprintf");
+				// console.log supplies the trailing newline.
+				return `console.log(${this._genPrintOperands(expr, " ", "")})`;
 			case "Fprintf":
 			case "Fprintln":
 			case "Fprint":
@@ -69,7 +72,7 @@ export const fmtMethods = {
 	},
 
 	_genFmtFprint(fn, expr) {
-		this._usesSprintf = true;
+		this.useHelper("sprintf");
 		const writerArg = expr.args[0];
 		const rest = expr.args.slice(1);
 		const restJs = rest.map((e) => this.genExpr(e)).join(", ");
@@ -93,8 +96,23 @@ export const fmtMethods = {
 		return `${w}.WriteString(${sprintfCall})`;
 	},
 
+	_genStdoutWrite(strJs) {
+		return `((__s) => (typeof process !== "undefined" && process?.stdout?.write ? process.stdout.write(__s) : console.log(__s)))(${strJs})`;
+	},
+
+	// Formats Print/Println operands with %v so the first operand is never
+	// mistaken for a format string.
+	_genPrintOperands(expr, sep, suffix) {
+		const argc = expr.args.length;
+		if (argc === 0) return JSON.stringify(suffix);
+		const fmt = Array(argc).fill("%v").join(sep) + suffix;
+		const args = expr.args.map((e) => this.genExpr(e)).join(", ");
+		return `__sprintf(${JSON.stringify(fmt)}, ${args})`;
+	},
+
 	_buildFprintSprintfCall(fn, argc, restJs) {
 		if (fn === "Fprintf") return `__sprintf(${restJs})`;
+		if (argc === 0) return fn === "Fprintln" ? '"\\n"' : '""';
 		const sep = fn === "Fprintln" ? " " : "";
 		const suffix = fn === "Fprintln" ? "\\n" : "";
 		const fmt = Array(argc).fill("%v").join(sep) + suffix;

package/src/backend/js/stdlib/index.js

@@ -15,6 +15,7 @@ import { osMethods } from "./os.js";
 import { pathMethods } from "./path.js";
 import { randMethods } from "./rand.js";
 import { regexpMethods } from "./regexp.js";
+import { sharedMethods } from "./shared.js";
 import { slicesMethods } from "./slices.js";
 import { sortMethods } from "./sort.js";
 import { strconvMethods } from "./strconv.js";
@@ -49,6 +50,7 @@ const STDLIB_METHOD_MAP = {
 	utf8: "_genUtf8",
 	path: "_genPath",
 	testing: "_genTesting",
+	shared: "_genShared",
 };
 
 const dispatchMethods = {
@@ -92,6 +94,7 @@ export const stdlibGenMethods = {
 	...pathMethods,
 	...randMethods,
 	...regexpMethods,
+	...sharedMethods,
 	...slicesMethods,
 	...sortMethods,
 	...strconvMethods,

package/src/backend/js/stdlib/maps.js

@@ -6,7 +6,7 @@
 export const mapsMethods = {
 	_genMaps(fn, a) {
 		if (fn === "Equal") {
-			this._usesEqual = true;
+			this.useHelper("equal");
 			const [a1, b1] = a();
 			return `__equal(${a1}, ${b1})`;
 		}

package/src/backend/js/stdlib/path.js

@@ -20,12 +20,12 @@ const PATH_DISPATCH = {
 export const pathMethods = {
 	_genPath(fn, a, expr) {
 		if (fn === "Join") {
-			this._usesPathClean = true;
+			this.useHelper("pathClean");
 			const allArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
 			return `__pathClean([${allArgs}].filter(x => x !== "").join("/"))`;
 		}
 		if (fn === "Clean") {
-			this._usesPathClean = true;
+			this.useHelper("pathClean");
 			return `__pathClean(${a()[0]})`;
 		}
 		const gen = PATH_DISPATCH[fn];

package/src/backend/js/stdlib/shared.js

@@ -0,0 +1,17 @@
+// CodeGen for the `gofront/shared` package: in js packages a shared buffer is
+// just a TypedArray (no linear memory is involved); in wasm packages the facade
+// hands out zero-copy views onto the module memory.
+
+import { SHARED_KINDS } from "../../../typechecker/stdlib/shared.js";
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
+export const sharedMethods = {
+	_genShared(fn, a) {
+		if (!fn.startsWith("New")) return undefined;
+		const info = SHARED_KINDS[fn.slice(3)];
+		if (!info) return undefined;
+		return `new ${info.ctor}(${a()[0]})`;
+	},
+};

package/src/backend/js/stdlib/slices.js

@@ -41,7 +41,7 @@ const SLICES_DISPATCH = {
 export const slicesMethods = {
 	_genSlices(fn, a) {
 		if (fn === "Equal") {
-			this._usesEqual = true;
+			this.useHelper("equal");
 			const [a1, b1] = a();
 			return `__equal(${a1}, ${b1})`;
 		}

package/src/backend/js/stdlib/sort.js

@@ -23,7 +23,7 @@ const SORT_DISPATCH = {
 /** @type {ThisType<CodeGen>} */
 export const sortMethods = {
 	_genSort(fn, a) {
-		if (fn === "Slice" || fn === "SliceStable") this._usesSortSlice = true;
+		if (fn === "Slice" || fn === "SliceStable") this.useHelper("sortSlice");
 		const gen = SORT_DISPATCH[fn];
 		return gen ? gen(a()) : undefined;
 	},

package/src/backend/js/stdlib/strconv.js

@@ -2,32 +2,57 @@
 
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
+// Parsers return [value, msg|null] from the shared __strconv_* helpers
+// (runtime.js); the message becomes a Go error value.
+const parsed = (call, toValue = "r[0]") =>
+	`((r) => [${toValue}, r[1] === null ? null : __error(r[1])])(${call})`;
+
 const STRCONV_DISPATCH = {
 	Itoa: (a) => `String(${a[0]})`,
-	Atoi: (a) =>
-		`(Number.isNaN(Number(${a[0]})) ? [0, "invalid syntax"] : [Number(${a[0]}) | 0, null])`,
+	Atoi: (a) => parsed(`__strconv_atoi(${a[0]})`, "Number(r[0])"),
 	FormatBool: (a) => `String(${a[0]})`,
 	FormatInt: (a) => `(${a[0]}).toString(${a[1]})`,
-	FormatFloat: (a) => `String(${a[0]})`,
-	ParseFloat: (a) =>
-		`(Number.isNaN(Number(${a[0]})) ? [0, "invalid syntax"] : [Number(${a[0]}), null])`,
+	FormatFloat: (a) =>
+		a.length < 3
+			? `String(${a[0]})`
+			: `__strconv_format_float(${a[0]}, ${a[1]}, ${a[2]})`,
+	ParseFloat: (a) => parsed(`__strconv_parse_float(${a[0]})`),
 	ParseInt: (a) =>
-		`(Number.isNaN(parseInt(${a[0]}, ${a[1]} || 10)) ? [0, "invalid syntax"] : [parseInt(${a[0]}, ${a[1]} || 10), null])`,
-	ParseBool: (a) =>
-		`(${a[0]} === "true" || ${a[0]} === "1" ? [true, null] : ${a[0]} === "false" || ${a[0]} === "0" ? [false, null] : [false, "invalid syntax"])`,
+		parsed(
+			`__strconv_parse_int(${a[0]}, ${a[1]}, ${a[2] ?? 64})`,
+			"Number(r[0])",
+		),
+	ParseBool: (a) => parsed(`__strconv_parse_bool(${a[0]})`),
 	Quote: (a) => `JSON.stringify(${a[0]})`,
 	Unquote: (a) =>
-		`((s) => { try { const v = JSON.parse(s); return [v, null]; } catch(e) { return ["", "invalid syntax"]; } })(${a[0]})`,
+		`((s) => { try { const v = JSON.parse(s); return [v, null]; } catch(e) { return ["", __error("invalid syntax")]; } })(${a[0]})`,
 	AppendInt: (a) =>
 		`[...(${a[0]}), ...new TextEncoder().encode((${a[1]}).toString(${a[2]}))]`,
 	AppendFloat: (a) =>
 		`[...(${a[0]}), ...new TextEncoder().encode(${a[1]}.toFixed(${a[3]} < 0 ? 6 : ${a[3]}))]`,
 };
 
+const USES_ERROR = new Set([
+	"Atoi",
+	"ParseFloat",
+	"ParseInt",
+	"ParseBool",
+	"Unquote",
+]);
+const USES_STRCONV = new Set([
+	"Atoi",
+	"ParseFloat",
+	"ParseInt",
+	"ParseBool",
+	"FormatFloat",
+]);
+
 /** @type {ThisType<CodeGen>} */
 export const strconvMethods = {
 	_genStrconv(fn, a) {
 		const gen = STRCONV_DISPATCH[fn];
+		if (gen && USES_ERROR.has(fn)) this.useHelper("error");
+		if (gen && USES_STRCONV.has(fn)) this.useHelper("strconv");
 		return gen ? gen(a()) : undefined;
 	},
 };

package/src/backend/js/stdlib/strings.js

@@ -21,7 +21,10 @@ const STRINGS_M2 = {
 const STRINGS_DISPATCH = {
 	Count: ([s, s2]) =>
 		`((s, sep) => sep === "" ? s.length + 1 : s.split(sep).length - 1)(${s}, ${s2})`,
-	Replace: ([s, s2, s3]) => `${s}.replace(${s2}, ${s3})`,
+	Replace: ([s, s2, s3, n]) =>
+		n === undefined
+			? `${s}.replace(${s2}, ${s3})`
+			: `((str, o, nw, cnt) => { if (cnt < 0) return str.replaceAll(o, nw); let r = ""; let i = 0; for (; cnt > 0; cnt--) { const j = str.indexOf(o, i); if (j < 0) break; r += str.slice(i, j) + nw; i = j + o.length; if (o.length === 0) { if (i >= str.length) break; r += str[i]; i++; } } return r + str.slice(i); })(${s}, ${s2}, ${s3}, ${n})`,
 	ReplaceAll: ([s, s2, s3]) => `${s}.replaceAll(${s2}, ${s3})`,
 	Trim: ([s, s2]) =>
 		`${s}.replace(new RegExp(\`^[\${${s2}}]+|[\${${s2}}]+$\`, "g"), "")`,

package/src/backend/js/stdlib/testing.js

@@ -15,7 +15,7 @@ export const testingMethods = {
 	},
 
 	_genTestingMethodCall(method, expr) {
-		this._usesTesting = true;
+		this.useHelper("testing");
 		const recv = expr.func.expr;
 		const t = this.genExpr(recv);
 		const args = expr.args
@@ -27,7 +27,7 @@ export const testingMethods = {
 			method === "Logf" ||
 			method === "Skipf"
 		) {
-			this._usesSprintf = true;
+			this.useHelper("sprintf");
 		}
 		return `${t}.${method}(${args})`;
 	},

package/src/backend/js/stdlib/time.js

@@ -35,11 +35,11 @@ export const timeMethods = {
 		const recvJs = this.genExpr(recv);
 		const args = expr.args.map((a) => this.genExpr(a));
 		if (method === "Format") {
-			this._usesTimeFmt = true;
+			this.useHelper("timeFmt");
 			return `__timeFmt(${recvJs}._d, ${args[0]})`;
 		}
 		if (method === "String") {
-			this._usesTimeFmt = true;
+			this.useHelper("timeFmt");
 			return `__timeFmt(${recvJs}._d, "2006-01-02T15:04:05Z07:00")`;
 		}
 		const gen = TIME_METHOD_DISPATCH[method];
@@ -48,7 +48,7 @@ export const timeMethods = {
 
 	_genTime(fn, a) {
 		if (fn === "Parse") {
-			this._usesTimeParse = true;
+			this.useHelper("timeParse");
 			return `__timeParse(${a()[0]}, ${a()[1]})`;
 		}
 		const gen = TIME_DISPATCH[fn];

package/src/backend/js/templ.js

@@ -286,7 +286,7 @@ export const templGenMethods = {
 		if (valName === "_")
 			return `for (const [${keyName}] of Object.entries(${iterJs})) {`;
 		// Default to .entries() for arrays, Object.entries for objects
-		this._usesSliceGuard = true;
+		this.useHelper("sliceGuard");
 		return `for (const [${keyName}, ${valName}] of __s(${iterJs}).entries()) {`;
 	},