gofront 1.3.12 → 1.5.1

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

@@ -1,6 +1,6 @@
 // Code generator: walks the typed AST and emits clean JavaScript.
 //
-// Split into sub-modules under codegen/:
+// Split into sub-modules under backend/js/:
 //   source-map.js    — VLQ encoder and source map builder
 //   statements.js    — genBlock, genStmt, genFor, genSwitch, etc.
 //   expressions.js   — genExpr, genCall, genCompositeLit, helpers
@@ -17,7 +17,12 @@
 //   - make(map[K]V)    → {}
 //   - for range        → for...of with .entries()
 
-import { isComplex, isNumeric } from "../typechecker/types.js";
+import {
+	computeEmbeddedStubs,
+	isReferenceType,
+	scanAddressTaken,
+} from "../../lower/index.js";
+import { isComplex, isNumeric } from "../../typechecker/types.js";
 import { expressionGenMethods } from "./expressions.js";
 import {
 	HELPER_APPEND,
@@ -27,6 +32,7 @@ import {
 	HELPER_ERROR,
 	HELPER_ERROR_IS,
 	HELPER_IFACE_BOX,
+	HELPER_INJECT_STYLES,
 	HELPER_LEN,
 	HELPER_PATH_CLEAN,
 	HELPER_S,
@@ -42,6 +48,8 @@ import { statementGenMethods } from "./statements.js";
 import { stdlibGenMethods } from "./stdlib/index.js";
 import { templGenMethods } from "./templ.js";
 
+export { buildSourceMap };
+
 // Valid Go identifiers that cannot be used as JS bindings; emitted with a `$` suffix.
 const JS_RESERVED = new Set([
 	"arguments",
@@ -90,13 +98,17 @@ export class CodeGen {
 		checker = null,
 		jsImports = new Map(),
 		bundledPackages = new Set(),
+		options = {},
 	) {
 		this.checker = checker;
+		this.target = options.target ?? "js";
+		this.strict = Boolean(options.strict || this.target === "both");
 		this.out = [];
 		this.indent = 0;
 		this.structNames = new Set();
 		this.structFields = new Map();
 		this.namedWrapperNames = new Set();
+		this.collectedCss = [];
 		this.jsImports = jsImports;
 		this.bundledPackages = bundledPackages;
 		this.namedReturnVars = null; // names of current function's named return vars
@@ -191,6 +203,10 @@ export class CodeGen {
 	}
 
 	_callInitAndMain(initNames, program, isTest = false) {
+		if (this.collectedCss.length > 0) {
+			const uniqueCss = [...new Set(this.collectedCss)];
+			this.line(`__injectStyles(${JSON.stringify(uniqueCss.join("\n\n"))});`);
+		}
 		for (const name of initNames) this.line(`${name}();`);
 		if (
 			!isTest &&
@@ -201,6 +217,14 @@ export class CodeGen {
 
 	generate(program, options = {}) {
 		const isTest = options.isTest ?? false;
+		// Ensure _pkgName is set on all decls (generateAll sets it for
+		// multi-file; for single-file compiles we derive it from the AST).
+		const pkgName = program.pkg?.name;
+		if (pkgName) {
+			for (const d of program.decls) {
+				if (!d._pkgName) d._pkgName = pkgName;
+			}
+		}
 		this._renameReservedIdents(program.decls);
 		const methods = this._collectDecls(program);
 		this._emitJsImports();
@@ -227,7 +251,7 @@ export class CodeGen {
 		return this.out.join("\n");
 	}
 
-	// Emits FuncDecl and TemplDecl nodes; returns renamed init function names.
+	// Emits FuncDecl, TemplDecl, and CssDecl nodes; returns renamed init function names.
 	_emitFuncDecls(program) {
 		let initCount = 0;
 		const initNames = [];
@@ -247,6 +271,10 @@ export class CodeGen {
 				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
 				this.genTemplDecl(d);
 				this.blank();
+			} else if (d.kind === "CssDecl") {
+				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
+				this.genCssDecl(d);
+				this.blank();
 			}
 		}
 		return initNames;
@@ -306,6 +334,7 @@ export class CodeGen {
 		MethodDecl: "_renameMethodDeclNode",
 		FuncLit: "_renameSignature",
 		TemplDecl: "_renameSignature",
+		CssDecl: "_renameSignature",
 		VarDecl: "_renameDeclSpecs",
 		ConstDecl: "_renameDeclSpecs",
 		TypeSwitchStmt: "_renameTypeSwitchNode",
@@ -381,6 +410,7 @@ export class CodeGen {
 	_prependHelpers(isTest = false) {
 		const needsTesting = isTest || this._usesTesting;
 		const HELPER_MAP = [
+			[this.collectedCss.length > 0, HELPER_INJECT_STYLES],
 			[this._usesLen, HELPER_LEN],
 			[this._usesAppend, HELPER_APPEND],
 			[this._usesSliceGuard, HELPER_S],
@@ -414,12 +444,17 @@ export class CodeGen {
 		for (let i = 0; i < programs.length; i++) {
 			for (const decl of programs[i].decls) {
 				decl._srcFileIdx = i;
+				decl._pkgName = programs[i].pkg?.name;
 			}
 		}
 		const merged = { decls: programs.flatMap((p) => p.decls) };
 		return this.generate(merged, options);
 	}
 
+	getCss() {
+		return [...new Set(this.collectedCss)].join("\n\n");
+	}
+
 	getMappings() {
 		return this._srcMappings;
 	}
@@ -596,12 +631,13 @@ export class CodeGen {
 	}
 
 	_genEmbeddedMethodStubs(name, methodDecls) {
-		if (!this.checker) return;
-		const resolvedType = this.checker.types.get(name)?.underlying;
-		if (resolvedType?.kind !== "struct" || !resolvedType._embeds) return;
-		const declared = new Set(methodDecls.map((m) => m.name));
-		for (const embed of resolvedType._embeds)
-			this._genSingleEmbedStubs(embed, declared);
+		const stubs = computeEmbeddedStubs(name, methodDecls, this.checker);
+		for (const stub of stubs) {
+			this.blank();
+			this.line(
+				`${stub.methodName}(...__a) { return ${stub.embedName}.prototype.${stub.methodName}.call(this, ...__a); }`,
+			);
+		}
 	}
 
 	genMethod(decl, recvField = null) {
@@ -742,36 +778,11 @@ export class CodeGen {
 
 	// Scan AST node for _addressTaken idents on scalars and populate _boxedVars.
 	_scanAddressTaken(node) {
-		if (!node || typeof node !== "object") return;
-		if (Array.isArray(node)) {
-			for (const child of node) this._scanAddressTaken(child);
-			return;
-		}
-		// &x — the operand ident will have _addressTaken set by typechecker
-		if (node.kind === "Ident" && node._addressTaken) {
-			// Check if the type is a scalar (needs boxing) vs reference type (no boxing)
-			const t = node._type;
-			if (t && !this._isReferenceType(t)) {
-				this._boxedVars.add(node.name);
-			}
-		}
-		// Recurse into FuncLit too — closures may take address of outer vars
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			this._scanAddressTaken(node[key]);
-		}
+		scanAddressTaken(node, this._boxedVars);
 	}
 
 	_isReferenceType(t) {
-		if (!t) return false;
-		const base = t.kind === "named" ? t.underlying : t;
-		return (
-			base?.kind === "struct" ||
-			base?.kind === "slice" ||
-			base?.kind === "map" ||
-			base?.kind === "func" ||
-			base?.kind === "interface"
-		);
+		return isReferenceType(t);
 	}
 
 	// ── Variable / const declarations ────────────────────────────

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

@@ -312,3 +312,14 @@ var __GoFront_T = __GoFront_T || class {
   }
 };
 var __testing_T = __GoFront_T;`;
+
+export const HELPER_INJECT_STYLES = `var __injectStyles = __injectStyles || function(css) {
+  if (typeof document === "undefined" || !document || !document.head || !css) return;
+  let s = document.getElementById("gofront-styles");
+  if (!s) {
+    s = document.createElement("style");
+    s.id = "gofront-styles";
+    document.head.appendChild(s);
+  }
+  s.textContent += "\\n" + css;
+};`;

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

@@ -1,6 +1,13 @@
-// CodeGen statement methods — installed as a mixin on CodeGen.prototype.
-
-import { isComplex, isNumeric } from "../typechecker/types.js";
+import {
+	bodyRedeclares,
+	isIntRangeType,
+	isMapRangeType,
+	isRangeFor,
+	isSimpleIntRange,
+	isStringRangeType,
+	nodeAssigns,
+} from "../../lower/index.js";
+import { isComplex } from "../../typechecker/types.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
@@ -55,9 +62,20 @@ export const statementGenMethods = {
 			case "TypeDecl":
 				this.genTypeDeclWithMethods(stmt, []);
 				break;
-			case "IncDecStmt":
-				this.line(`${this.genExpr(stmt.expr)}${stmt.op};`);
+			case "IncDecStmt": {
+				if (
+					this.strict &&
+					this._genStrictCompound(
+						stmt.expr,
+						stmt.op === "++" ? "+" : "-",
+						"1",
+						srcLine,
+					)
+				)
+					break;
+				this.line(`${this.genExpr(stmt.expr)}${stmt.op};`, srcLine);
 				break;
+			}
 			case "ExprStmt":
 				this.line(`${this.genExpr(stmt.expr)};`);
 				break;
@@ -248,6 +266,19 @@ export const statementGenMethods = {
 		if (active.length === 0) {
 			if (rhs.length > 0) this.line(`${rhs[0]};`);
 		} else if (lhs.length === 1) {
+			if (
+				this.strict &&
+				stmt.op !== "=" &&
+				this._genStrictCompound(
+					stmt.lhs[0],
+					stmt.op.slice(0, -1),
+					active[0].r,
+					null,
+					active[0].l,
+				)
+			) {
+				return;
+			}
 			this.line(`${active[0].l} ${stmt.op} ${active[0].r};`);
 		} else {
 			this._genAssignMulti(stmt, lhs, rhs, active, pairs);
@@ -449,28 +480,19 @@ export const statementGenMethods = {
 	},
 
 	isRangeFor(stmt) {
-		if (!stmt.init) return false;
-		const init = stmt.init;
-		if (init.kind !== "DefineStmt" && init.kind !== "AssignStmt") return false;
-		return init.rhs?.[0]?.kind === "RangeExpr";
+		return isRangeFor(stmt);
 	},
 
 	_isIntRangeType(iterType) {
-		return isNumeric(iterType);
+		return isIntRangeType(iterType);
 	},
 
 	_isMapRangeType(iterType) {
-		return (
-			iterType?.kind === "map" ||
-			(iterType?.kind === "named" && iterType.underlying?.kind === "map")
-		);
+		return isMapRangeType(iterType);
 	},
 
 	_isStringRangeType(iterType) {
-		return (
-			(iterType?.kind === "basic" && iterType.name === "string") ||
-			(iterType?.kind === "untyped" && iterType.base === "string")
-		);
+		return isStringRangeType(iterType);
 	},
 
 	_rangeVarTarget(e, isAssign) {
@@ -498,17 +520,7 @@ export const statementGenMethods = {
 
 	// True when the body re-declares one of `names` at its top level (legal Go shadowing).
 	_bodyRedeclares(body, names) {
-		if (names.length === 0) return false;
-		for (const s of body.stmts ?? []) {
-			if (s.kind === "DefineStmt" && s.lhs.some((e) => names.includes(e.name)))
-				return true;
-			if (
-				(s.kind === "VarDecl" || s.kind === "ConstDecl") &&
-				s.decls?.some((d) => d.names?.some((n) => names.includes(n)))
-			)
-				return true;
-		}
-		return false;
+		return bodyRedeclares(body, names);
 	},
 
 	// Range value variable: aliases the element unless the body writes the variable or the collection.
@@ -565,9 +577,7 @@ export const statementGenMethods = {
 
 	// Whether `for i := range n` can be emitted as a plain `for (let i = 0; …)` without hidden registers.
 	_isSimpleIntRange(stmt, name, isAssign) {
-		if (isAssign) return false;
-		if (!name || name === "_") return true;
-		return !this._boxedVars.has(name) && !this._nodeAssigns(stmt.body, name);
+		return isSimpleIntRange(stmt, name, isAssign, this._boxedVars);
 	},
 
 	_genIntRangeBody(stmt, name, isAssign) {
@@ -603,22 +613,7 @@ export const statementGenMethods = {
 
 	// True when `node` contains an assignment or ++/-- targeting identifier `name`.
 	_nodeAssigns(node, name) {
-		if (!node || typeof node !== "object") return false;
-		if (Array.isArray(node))
-			return node.some((n) => this._nodeAssigns(n, name));
-		if (
-			(node.kind === "AssignStmt" &&
-				node.lhs.some((e) => e.kind === "Ident" && e.name === name)) ||
-			(node.kind === "IncDecStmt" &&
-				node.expr.kind === "Ident" &&
-				node.expr.name === name)
-		)
-			return true;
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			if (this._nodeAssigns(node[key], name)) return true;
-		}
-		return false;
+		return nodeAssigns(node, name);
 	},
 
 	_genIterFor(init, iterType, iteree, lhs, body) {

package/src/backend/js/stdlib/bits.js

@@ -0,0 +1,32 @@
+// src/backend/js/stdlib/bits.js
+// CodeGen for Go `math/bits` package.
+
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+const BITS_MAP = {
+	LeadingZeros32: ([x]) => `Math.clz32((${x}) >>> 0)`,
+	TrailingZeros32: ([x]) =>
+		`((() => { const v = (${x}) >>> 0; return v === 0 ? 32 : 31 - Math.clz32(v & -v); })())`,
+	OnesCount32: ([x]) =>
+		`((() => { let v = (${x}) >>> 0; v = v - ((v >>> 1) & 0x55555555); v = (v & 0x33333333) + ((v >>> 2) & 0x33333333); return (Math.imul((v + (v >>> 4)) & 0x0f0f0f0f, 0x01010101)) >>> 24; })())`,
+	RotateLeft32: ([x, k]) =>
+		`((() => { const s = (${k}) & 31; const v = (${x}) >>> 0; return ((v << s) | (v >>> ((32 - s) & 31))) >>> 0; })())`,
+
+	LeadingZeros64: ([x]) =>
+		`((() => { const v = BigInt.asUintN(64, BigInt(${x})); if (v === 0n) return 64; const hi = Number(v >> 32n); return hi !== 0 ? Math.clz32(hi) : 32 + Math.clz32(Number(v & 0xffffffffn)); })())`,
+	TrailingZeros64: ([x]) =>
+		`((() => { const v = BigInt.asUintN(64, BigInt(${x})); if (v === 0n) return 64; const lo = Number(v & 0xffffffffn); if (lo !== 0) return 31 - Math.clz32(lo & -lo); const hi = Number((v >> 32n) & 0xffffffffn); return 32 + (31 - Math.clz32(hi & -hi)); })())`,
+	OnesCount64: ([x]) =>
+		`((() => { let v = BigInt.asUintN(64, BigInt(${x})); let c = 0; while (v > 0n) { if (v & 1n) c++; v >>= 1n; } return c; })())`,
+	RotateLeft64: ([x, k]) =>
+		`((() => { const s = BigInt(${k}) & 63n; const v = BigInt.asUintN(64, BigInt(${x})); return BigInt.asUintN(64, (v << s) | (v >> ((64n - s) & 63n))); })())`,
+};
+
+/** @type {ThisType<CodeGen>} */
+export const bitsMethods = {
+	_genBits(fn, a) {
+		const args = a();
+		const gen = BITS_MAP[fn];
+		return gen ? gen(args) : undefined;
+	},
+};

package/src/{codegen → backend/js}/stdlib/index.js

@@ -1,6 +1,7 @@
 // CodeGen stdlib call generation — installed as a mixin on CodeGen.prototype.
 // One file per Go package under ./stdlib/. This index merges them.
 
+import { bitsMethods } from "./bits.js";
 import { builderMethods } from "./builder.js";
 import { bytesMethods } from "./bytes.js";
 import { errorsMethods } from "./errors.js";
@@ -34,6 +35,7 @@ const STDLIB_METHOD_MAP = {
 	strconv: "_genStrconv",
 	sort: "_genSort",
 	math: "_genMath",
+	bits: "_genBits",
 	unicode: "_genUnicode",
 	os: "_genOs",
 	errors: "_genErrors",
@@ -76,6 +78,7 @@ const dispatchMethods = {
 
 /** @type {ThisType<CodeGen>} */
 export const stdlibGenMethods = {
+	...bitsMethods,
 	...builderMethods,
 	...bytesMethods,
 	...errorsMethods,

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

@@ -2,8 +2,8 @@
 // Mounts an HTML/expression tree onto a parent DOM node by emitting plain
 // document.createElement / appendChild / setAttribute calls.
 
-import { Parser } from "../parser/index.js";
-import { T, Token } from "../tokens.js";
+import { Parser } from "../../parser/index.js";
+import { T, Token } from "../../tokens.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
@@ -26,6 +26,35 @@ export const templGenMethods = {
 		this.line("}");
 	},
 
+	genCssDecl(decl) {
+		if (decl.params && decl.params.length > 0) {
+			throw new Error(
+				`css ${decl.name}: parameterized css declarations are not yet supported`,
+			);
+		}
+		const className = this.getCssClassName(decl);
+		const scopedCss = `.${className} {\n${decl.cssText.trim()}\n}`;
+		this.collectedCss.push(scopedCss);
+
+		this.line(`function ${decl.name}() {`);
+		this.indented(() => {
+			this.line(`return ${JSON.stringify(className)};`);
+		});
+		this.line("}");
+	},
+
+	getCssClassName(decl) {
+		if (decl._className) return decl._className;
+		let h = 2166136261 >>> 0;
+		const str = `${decl._pkgName || ""}_${decl.name}_${decl.cssText}`;
+		for (let i = 0; i < str.length; i++) {
+			h = Math.imul(h ^ str.charCodeAt(i), 16777619) >>> 0;
+		}
+		const hash = (h >>> 0).toString(36);
+		decl._className = `gfc_${decl.name}_${hash}`;
+		return decl._className;
+	},
+
 	// Emit mount statements for an array of TemplNodes into parent variable `p`.
 	_genTemplNodes(nodes, p) {
 		if (!nodes || nodes.length === 0) return;