gofront 1.6.1 → 1.7.0

package/src/typechecker/index.js

@@ -57,6 +57,7 @@ export class TypeChecker {
 		this._typeSwitchDepth = 0; // for rejecting fallthrough in type switch
 		this._deferCount = 0; // tracks defer usage in current function body
 		this._imports = []; // tracked imports for unused-import detection
+		this._constExprs = new Map(); // name -> AST initializer expr
 		this._setupGlobals();
 		// Register error as a named type (interface)
 		this.types.set("error", ERROR);
@@ -220,7 +221,11 @@ export class TypeChecker {
 			const type = spec.type
 				? this.resolveTypeNode(spec.type, this.globals)
 				: ANY;
-			for (const name of spec.names) this.globals.defineConst(name, type);
+			for (let i = 0; i < spec.names.length; i++) {
+				const name = spec.names[i];
+				const expr = spec.value?.[i] ?? spec.value?.[0] ?? null;
+				this.globals.defineConst(name, type, expr);
+			}
 		}
 	}
 
@@ -510,7 +515,8 @@ export class TypeChecker {
 			const struct = type.underlying;
 			if (struct?.kind === "struct" && struct._embeds) {
 				for (const embed of struct._embeds) {
-					const base = embed.kind === "named" ? embed.underlying : embed;
+					const inner = embed.kind === "pointer" ? embed.base : embed;
+					const base = inner.kind === "named" ? inner.underlying : inner;
 					if (base?.kind !== "struct" || !base.methods) continue;
 					for (const [mName, mType] of base.methods.entries()) {
 						if (!struct.methods.has(mName)) struct.methods.set(mName, mType);
@@ -899,14 +905,31 @@ export class TypeChecker {
 			let type = spec.type ? this.resolveTypeNode(spec.type, scope) : null;
 			if (spec.value) {
 				const valTypes = spec.value.map((v) => this.checkExpr(v, scope));
-				if (!type) type = defaultType(valTypes[0]) ?? ANY;
+				const isTuple = valTypes.length === 1 && valTypes[0]?.kind === "tuple";
+				const valTypesFlat = isTuple ? valTypes[0].types : valTypes;
+				if (spec.names.length !== valTypesFlat.length) {
+					const vars =
+						spec.names.length === 1
+							? "1 variable"
+							: `${spec.names.length} variables`;
+					const vals = isTuple
+						? `returns ${valTypesFlat.length} values`
+						: valTypesFlat.length === 1
+							? "1 value"
+							: `${valTypesFlat.length} values`;
+					this.err(`assignment mismatch: ${vars} but ${vals}`, spec);
+				}
 				for (let i = 0; i < spec.names.length; i++) {
-					const vt = valTypes[i] ?? ANY;
-					this.assertAssignable(type, vt, spec.value[i]);
+					const vt = valTypesFlat[i] ?? ANY;
+					const varType = type ?? defaultType(vt) ?? ANY;
+					if (type)
+						this.assertAssignable(type, vt, spec.value[i] ?? spec.value[0]);
+					scope.defineLocal(spec.names[i], varType);
 				}
+			} else {
+				if (!type) type = ANY;
+				for (const name of spec.names) scope.defineLocal(name, type);
 			}
-			if (!type) type = ANY;
-			for (const name of spec.names) scope.defineLocal(name, type);
 		}
 		this._sharedAllocOk = savedSharedAlloc;
 	}
@@ -918,7 +941,11 @@ export class TypeChecker {
 			const type = spec.type
 				? this.resolveTypeNode(spec.type, scope)
 				: (valTypes[0] ?? ANY);
-			for (const name of spec.names) scope.defineConst(name, type);
+			for (let i = 0; i < spec.names.length; i++) {
+				const name = spec.names[i];
+				const expr = spec.value?.[i] ?? spec.value?.[0] ?? null;
+				scope.defineConst(name, type, expr);
+			}
 		}
 	}
 

package/src/typechecker/resolve.js

@@ -1,6 +1,7 @@
 // Type resolution methods — resolveTypeNode, resolveType, fieldType, generics.
 // Installed as a mixin on TypeChecker.prototype.
 
+import { parseJsonTag } from "../parser/struct-tag.js";
 import {
 	ANY,
 	BASIC_TYPES,
@@ -209,10 +210,28 @@ export const resolveMethods = {
 	_resolveStructType(node, scope) {
 		const fields = new Map();
 		const embeds = [];
+		const structFields = [];
 		for (const f of node.fields) {
 			const ft = this.resolveTypeNode(f.type, scope);
+			structFields.push({
+				names: f.names,
+				type: ft,
+				tag: f.tag ?? null,
+				embedded: Boolean(f.embedded),
+				astType: f.type,
+			});
 			if (f.embedded) {
-				const base = ft.kind === "named" ? ft.underlying : ft;
+				const inner = ft.kind === "pointer" ? ft.base : ft;
+				const embedName = (
+					f.astType?.name ??
+					f.type?.name ??
+					f.type?.base?.name ??
+					(inner.kind === "named" ? inner.name : "")
+				)
+					.split(".")
+					.pop();
+				if (embedName) fields.set(embedName, ft);
+				const base = inner.kind === "named" ? inner.underlying : inner;
 				if (base?.kind === "struct") {
 					for (const [k, v] of base.fields.entries()) fields.set(k, v);
 				}
@@ -221,7 +240,13 @@ export const resolveMethods = {
 				for (const n of f.names) fields.set(n, ft);
 			}
 		}
-		return { kind: "struct", fields, methods: new Map(), _embeds: embeds };
+		return {
+			kind: "struct",
+			fields,
+			methods: new Map(),
+			_embeds: embeds,
+			_structFields: structFields,
+		};
 	},
 
 	_resolveInterfaceType(node, scope) {
@@ -434,6 +459,7 @@ export const resolveMethods = {
 			case "namespace":
 				return this._fieldTypeNamespace(base, field, node);
 			case "shared":
+			case "simd":
 				if (base.methods?.has(field)) return base.methods.get(field);
 				return this.err(`No method '${field}' on ${typeStr(baseType)}`, node);
 			case "slice":
@@ -537,4 +563,127 @@ export const resolveMethods = {
 		}
 		return this.err(`No member '${field}' in namespace ${base.name}`, node);
 	},
+
+	resolveJsonFields(structType) {
+		return resolveJsonFields(structType);
+	},
 };
+
+function isExported(name) {
+	if (!name || typeof name !== "string") return false;
+	const code = name.charCodeAt(0);
+	return code >= 65 && code <= 90;
+}
+
+function _processJsonField(f, depth, path, visited, queue, candidates) {
+	const tagInfo = parseJsonTag(f.tag);
+	if (tagInfo.ignored) return;
+
+	if (f.embedded) {
+		const isPtr = f.type.kind === "pointer" || f.type.kind === "PointerType";
+		const inner = isPtr ? f.type.base : f.type;
+		const embedStruct = inner.kind === "named" ? inner.underlying : inner;
+		const embedName = (
+			f.astType?.name ??
+			f.astType?.base?.name ??
+			inner.name ??
+			""
+		)
+			.split(".")
+			.pop();
+
+		if (tagInfo.name !== null) {
+			if (isExported(embedName)) {
+				candidates.push({
+					jsonKey: tagInfo.name,
+					goName: embedName,
+					type: f.type,
+					omitempty: tagInfo.omitempty,
+					depth,
+					tagged: true,
+					isEmbedded: true,
+					path: [...path, { name: embedName, isPtr, typeName: embedName }],
+				});
+			}
+		} else if (embedStruct?.kind === "struct") {
+			if (!visited.has(embedStruct)) {
+				const nextVisited = new Set(visited);
+				nextVisited.add(embedStruct);
+				queue.push({
+					struct: embedStruct,
+					depth: depth + 1,
+					path: [...path, { name: embedName, isPtr, typeName: embedName }],
+					visited: nextVisited,
+				});
+			}
+		}
+		return;
+	}
+
+	for (const name of f.names) {
+		if (!isExported(name)) continue;
+		candidates.push({
+			jsonKey: tagInfo.name !== null ? tagInfo.name : name,
+			goName: name,
+			type: f.type,
+			omitempty: tagInfo.omitempty,
+			quoted: tagInfo.options.includes("string"),
+			depth,
+			tagged: tagInfo.name !== null,
+			path: [...path, { name, isPtr: false }],
+		});
+	}
+}
+
+function _resolveCandidateCollisions(candidates) {
+	const byKey = new Map();
+	for (const cand of candidates) {
+		if (!byKey.has(cand.jsonKey)) byKey.set(cand.jsonKey, []);
+		byKey.get(cand.jsonKey).push(cand);
+	}
+
+	const winningFields = [];
+	for (const [, group] of byKey.entries()) {
+		let minDepth = Infinity;
+		for (const c of group) {
+			if (c.depth < minDepth) minDepth = c.depth;
+		}
+
+		const atMin = group.filter((c) => c.depth === minDepth);
+		if (atMin.length === 1) {
+			winningFields.push(atMin[0]);
+		} else {
+			const tagged = atMin.filter((c) => c.tagged);
+			if (tagged.length === 1) winningFields.push(tagged[0]);
+		}
+	}
+
+	winningFields.sort((a, b) => candidates.indexOf(a) - candidates.indexOf(b));
+	return winningFields;
+}
+
+export function resolveJsonFields(structType) {
+	if (!structType) return [];
+	const underlying =
+		structType.kind === "named" ? structType.underlying : structType;
+	if (underlying?.kind !== "struct") return [];
+	if (underlying._jsonFields) return underlying._jsonFields;
+
+	const queue = [
+		{ struct: underlying, depth: 0, path: [], visited: new Set([underlying]) },
+	];
+	const candidates = [];
+
+	while (queue.length > 0) {
+		const { struct: curr, depth, path, visited } = queue.shift();
+		if (curr?.kind !== "struct") continue;
+
+		for (const f of curr._structFields || []) {
+			_processJsonField(f, depth, path, visited, queue, candidates);
+		}
+	}
+
+	const winning = _resolveCandidateCollisions(candidates);
+	underlying._jsonFields = winning;
+	return winning;
+}

package/src/typechecker/statements.js

@@ -83,6 +83,29 @@ export const statementCheckMethods = {
 		}
 	},
 
+	_checkDefineCommaOkMap(stmt, scope) {
+		if (
+			stmt.lhs.length !== 2 ||
+			stmt.rhs.length !== 1 ||
+			stmt.rhs[0].kind !== "IndexExpr"
+		)
+			return false;
+		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
+		const resolvedBase =
+			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
+		if (resolvedBase?.kind !== "map") return false;
+		this.checkExpr(stmt.rhs[0].index, scope);
+		stmt._commaOkMap = true;
+		stmt.rhs[0]._mapValueType = resolvedBase.value;
+		this._declareDefineVars(stmt, [resolvedBase.value, BOOL], scope);
+		const allRedecl = stmt.lhs.every((e) => e._redecl || (e.name ?? e) === "_");
+		if (allRedecl && stmt.lhs.length > 0) {
+			this.err("no new variables on left side of :=", stmt.lhs[0]);
+		}
+		stmt._rhsTypes = [resolvedBase.value, BOOL];
+		return true;
+	},
+
 	_checkDefineStmt(stmt, scope) {
 		// comma-ok type assertion: n, ok := x.(T)
 		if (
@@ -92,10 +115,24 @@ export const statementCheckMethods = {
 		) {
 			stmt.rhs[0]._commaOk = true;
 		}
+		if (this._checkDefineCommaOkMap(stmt, scope)) return;
 		const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
-		const rhsFlat =
-			rhs.length === 1 && rhs[0].kind === "tuple" ? rhs[0].types : rhs;
+		const isTuple = rhs.length === 1 && rhs[0]?.kind === "tuple";
+		const rhsFlat = isTuple ? rhs[0].types : rhs;
 		if (this._checkDefineCommaOkAssert(stmt, rhs, scope)) return;
+		if (
+			stmt.rhs[0]?.kind !== "RangeExpr" &&
+			stmt.lhs.length !== rhsFlat.length
+		) {
+			const vars =
+				stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
+			const vals = isTuple
+				? `returns ${rhsFlat.length} values`
+				: rhsFlat.length === 1
+					? "1 value"
+					: `${rhsFlat.length} values`;
+			this.err(`assignment mismatch: ${vars} but ${vals}`, stmt);
+		}
 		this._declareDefineVars(stmt, rhsFlat, scope);
 		const allRedecl = stmt.lhs.every((e) => e._redecl || (e.name ?? e) === "_");
 		if (allRedecl && stmt.lhs.length > 0) {
@@ -110,15 +147,15 @@ export const statementCheckMethods = {
 			stmt.rhs.length !== 1 ||
 			stmt.rhs[0].kind !== "IndexExpr"
 		)
-			return false;
+			return null;
 		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
 		const resolvedBase =
 			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
-		if (resolvedBase?.kind !== "map") return false;
+		if (resolvedBase?.kind !== "map") return null;
 		this.checkExpr(stmt.rhs[0].index, scope);
 		stmt._commaOkMap = true;
 		stmt.rhs[0]._mapValueType = resolvedBase.value;
-		return true;
+		return [resolvedBase.value, BOOL];
 	},
 
 	_checkConstAssignment(stmt, scope) {
@@ -163,12 +200,34 @@ export const statementCheckMethods = {
 	},
 
 	_checkAssignStmt(stmt, scope) {
-		if (this._checkAssignCommaOkMap(stmt, scope)) return;
+		const commaOkMapTypes = this._checkAssignCommaOkMap(stmt, scope);
 		if (this._isCommaOkTypeAssertAssign(stmt)) stmt.rhs[0]._commaOk = true;
 		this._checkConstAssignment(stmt, scope);
-		const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
-		const rhsFlat =
-			rhs.length === 1 && rhs[0]?.kind === "tuple" ? rhs[0].types : rhs;
+		let rhsFlat;
+		if (commaOkMapTypes) {
+			rhsFlat = commaOkMapTypes;
+		} else {
+			const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
+			const isTuple = rhs.length === 1 && rhs[0]?.kind === "tuple";
+			rhsFlat = isTuple ? rhs[0].types : rhs;
+			if (
+				!stmt.rhs[0]?._commaOk &&
+				stmt.rhs[0]?.kind !== "RangeExpr" &&
+				stmt.lhs.length !== rhsFlat.length
+			) {
+				const vars =
+					stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
+				const vals = isTuple
+					? `returns ${rhsFlat.length} values`
+					: rhsFlat.length === 1
+						? "1 value"
+						: `${rhsFlat.length} values`;
+				this.err(`assignment mismatch: ${vars} but ${vals}`, stmt);
+			}
+			if (stmt.rhs[0]?._commaOk) {
+				rhsFlat = [rhs[0], BOOL];
+			}
+		}
 		const lhsTypes = stmt.lhs.map((e) => this._checkAssignLhsType(e, scope));
 		this._checkAssignTypes(stmt, rhsFlat, lhsTypes);
 	},

package/src/typechecker/stdlib/extended.js

@@ -853,6 +853,43 @@ export function setupExtendedGlobals(globals, types) {
 	types.set("encoding/base64.Encoding", BASE64_ENCODING_T);
 	types.set("base64.Encoding", BASE64_ENCODING_T);
 
+	// ── encoding/json ─────────────────────────────────────────────
+	const RAW_MESSAGE_T = {
+		kind: "named",
+		name: "json.RawMessage",
+		underlying: BYTE_SLICE,
+		methods: new Map(),
+	};
+	globals.define("json", {
+		kind: "namespace",
+		name: "json",
+		members: {
+			Marshal: {
+				kind: "func",
+				params: [ANY],
+				returns: [BYTE_SLICE, ERROR],
+			},
+			MarshalIndent: {
+				kind: "func",
+				params: [ANY, STRING, STRING],
+				returns: [BYTE_SLICE, ERROR],
+			},
+			Unmarshal: {
+				kind: "func",
+				params: [BYTE_SLICE, ANY],
+				returns: [ERROR],
+			},
+			Valid: {
+				kind: "func",
+				params: [BYTE_SLICE],
+				returns: [BOOL],
+			},
+			RawMessage: RAW_MESSAGE_T,
+		},
+	});
+	types.set("encoding/json.RawMessage", RAW_MESSAGE_T);
+	types.set("json.RawMessage", RAW_MESSAGE_T);
+
 	for (const name of [
 		"append",
 		"len",

package/src/typechecker/stdlib/simd.js

@@ -0,0 +1,73 @@
+// src/typechecker/stdlib/simd.js
+// `gofront/simd` — WebAssembly SIMD types and vector operations.
+//
+// F32x4 is a 128-bit 4-wide float32 vector with Go value semantics:
+// - Lowered to WASM v128 in wasm packages.
+// - Lowered to a frozen 4-number array with Math.fround in js packages.
+
+import { FLOAT32, INT } from "../types.js";
+
+export function setupSimdGlobals(globals, types) {
+	const f32x4Type = {
+		kind: "named",
+		name: "simd.F32x4",
+		underlying: {
+			kind: "simd",
+			simd: "F32x4",
+			elem: FLOAT32,
+			lanes: 4,
+		},
+	};
+
+	f32x4Type.underlying.methods = new Map([
+		["Add", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Sub", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Mul", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Div", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Min", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Max", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Dot3", { kind: "func", params: [f32x4Type], returns: [FLOAT32] }],
+		["Dot4", { kind: "func", params: [f32x4Type], returns: [FLOAT32] }],
+		["Lane", { kind: "func", params: [INT], returns: [FLOAT32] }],
+		[
+			"WithLane",
+			{ kind: "func", params: [INT, FLOAT32], returns: [f32x4Type] },
+		],
+		["Splat", { kind: "func", params: [FLOAT32], returns: [f32x4Type] }],
+	]);
+
+	types.set("simd.F32x4", f32x4Type);
+	types.set("F32x4", f32x4Type);
+
+	const sharedFloat32 = types.get("shared.Float32") ?? {
+		kind: "named",
+		name: "shared.Float32",
+		underlying: { kind: "shared", elem: FLOAT32, shared: "Float32" },
+	};
+
+	const members = {
+		F32x4: f32x4Type,
+		NewF32x4: {
+			kind: "func",
+			params: [FLOAT32, FLOAT32, FLOAT32, FLOAT32],
+			returns: [f32x4Type],
+		},
+		Splat: {
+			kind: "func",
+			params: [FLOAT32],
+			returns: [f32x4Type],
+		},
+		LoadF32x4: {
+			kind: "func",
+			params: [sharedFloat32, INT],
+			returns: [f32x4Type],
+		},
+		StoreF32x4: {
+			kind: "func",
+			params: [sharedFloat32, INT, f32x4Type],
+			returns: [],
+		},
+	};
+
+	globals.define("simd", { kind: "namespace", name: "simd", members });
+}

package/src/typechecker/stdlib.js

@@ -10,11 +10,13 @@
 import { setupCoreGlobals } from "./stdlib/core.js";
 import { setupExtendedGlobals } from "./stdlib/extended.js";
 import { setupSharedGlobals } from "./stdlib/shared.js";
+import { setupSimdGlobals } from "./stdlib/simd.js";
 import { setupWebGlobals } from "./stdlib/web.js";
 
 export function setupGlobals(globals, types) {
 	setupCoreGlobals(globals, types);
 	setupExtendedGlobals(globals, types);
 	setupSharedGlobals(globals, types);
+	setupSimdGlobals(globals, types);
 	setupWebGlobals(globals, types);
 }

package/src/typechecker/types.js

@@ -126,6 +126,7 @@ export const WASM_SUPPORTED_STDLIB = new Set([
 	"time",
 	"testing",
 	"gofront/shared",
+	"gofront/simd",
 	"sync",
 	"crypto/rand",
 	"crypto/sha256",
@@ -139,12 +140,14 @@ export const STDLIB_PACKAGES = new Set([
 	"os",
 	"gom",
 	"regexp",
+	"encoding/json",
 ]);
 
 // Per-namespace member subset the WASM backend implements. `null` means every
 // member the checker knows about. Members outside the set are rejected in
 // wasm/both packages with "'strings.Split' is not yet available in wasm packages".
 export const WASM_STDLIB_MEMBERS = new Map([
+	["json", new Set()],
 	[
 		"math",
 		new Set([
@@ -839,8 +842,13 @@ export function typeStr(t) {
 			return t.name || "interface{...}";
 		case "namespace":
 			return t.name || "namespace{...}";
-		case "func":
-			return `func(${t.params.map(typeStr).join(", ")}) ${typeStr(t.returns[0] ?? VOID)}`;
+		case "func": {
+			const retStr =
+				t.returns.length > 1
+					? `(${t.returns.map(typeStr).join(", ")})`
+					: typeStr(t.returns[0] ?? VOID);
+			return `func(${t.params.map(typeStr).join(", ")}) ${retStr}`;
+		}
 		case "tuple":
 			return `(${t.types.map(typeStr).join(", ")})`;
 		case "named":
@@ -887,6 +895,7 @@ export class Scope {
 		this.parent = parent;
 		this.symbols = new Map();
 		this._consts = new Set(); // names declared as const in this scope
+		this._constExprs = new Map(); // name -> AST initializer expr
 		this._locals = new Set(); // names declared as local variables (var / :=)
 		this._used = new Set(); // names referenced in this scope
 	}
@@ -897,9 +906,15 @@ export class Scope {
 		this.symbols.set(name, type);
 		if (name !== "_") this._locals.add(name);
 	}
-	defineConst(name, type) {
+	defineConst(name, type, expr = null) {
 		this.symbols.set(name, type);
 		this._consts.add(name);
+		if (expr) this._constExprs.set(name, expr);
+	}
+	lookupConstExpr(name) {
+		if (this._constExprs.has(name)) return this._constExprs.get(name);
+		if (this.parent) return this.parent.lookupConstExpr(name);
+		return null;
 	}
 	isConst(name) {
 		if (this._consts.has(name)) return true;