gofront 1.4.0 → 1.5.1

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 */