gofront 1.5.1 → 1.6.0

package/src/typechecker/expressions.js

@@ -1,5 +1,6 @@
 // TypeChecker expression-checking methods — installed as a mixin on TypeChecker.prototype.
 
+import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
 	BOOL,
@@ -42,6 +43,13 @@ const BUILTIN_CHECK = {
 			s.err(`cannot append to array (type ${typeStr(st)})`, e);
 			return st;
 		}
+		if (sharedInfo(st)) {
+			s.err(
+				`cannot append to ${typeStr(st)}: shared buffers have a fixed size`,
+				e,
+			);
+			return st;
+		}
 		const sb = s.resolveType(st?.kind === "named" ? st.underlying : st);
 		if (sb?.kind === "slice") {
 			for (let i = 1; i < e.args.length; i++) {
@@ -55,7 +63,7 @@ const BUILTIN_CHECK = {
 		}
 		return st;
 	},
-	copy: () => INT,
+	copy: (s, _n, e, at) => s._checkBuiltinCopy(e, at),
 	delete: () => VOID,
 	make: (s, _n, e, _at, sc) => {
 		if (e.args.length < 1) return ANY;
@@ -291,10 +299,42 @@ export const expressionCheckMethods = {
 			expr._mapValueType = btu.value;
 			return btu.value;
 		}
+		if (btu.kind === "shared") {
+			expr._sharedElem = btu.elem;
+			const idx = this._constIntValue(expr.index);
+			if (idx !== null && idx < 0)
+				this.err(`invalid index ${idx} (index must not be negative)`, expr);
+			return btu.elem;
+		}
 		if (isString(bt)) return INT;
 		return this.err(`Cannot index type ${typeStr(bt)}`, expr);
 	},
 
+	// copy(dst, src): element types must be identical when either side is a
+	// shared buffer (the wasm emitter uses one element type for both sides).
+	_checkBuiltinCopy(e, at) {
+		const elemOf = (t) => {
+			const u = this.resolveType(t?.kind === "named" ? t.underlying : t);
+			return u?.kind === "slice" || u?.kind === "shared" ? u.elem : null;
+		};
+		const [dt, st] = at;
+		if (!sharedInfo(dt) && !sharedInfo(st)) return INT;
+		const de = elemOf(dt);
+		const se = elemOf(st);
+		if (!de || !se) {
+			this.err(
+				`copy: cannot copy between ${typeStr(dt)} and ${typeStr(st)}`,
+				e,
+			);
+		} else if (typeStr(de) !== typeStr(se)) {
+			this.err(
+				`copy: element types differ (${typeStr(dt)} vs ${typeStr(st)})`,
+				e,
+			);
+		}
+		return INT;
+	},
+
 	_checkSliceExpr(expr, scope) {
 		const bt = this.checkExpr(expr.expr, scope);
 		if (expr.low) this.checkExpr(expr.low, scope);
@@ -305,10 +345,25 @@ export const expressionCheckMethods = {
 		if (bt.kind === "slice" || bt.kind === "array")
 			return { kind: "slice", elem: bt.elem };
 		if (isString(bt)) return STRING;
+		if (sharedInfo(bt))
+			return this.err(
+				`Cannot slice type ${typeStr(bt)}: use .Subarray(lo, hi) to create a view of a shared buffer`,
+				expr,
+			);
 		return this.err(`Cannot slice type ${typeStr(bt)}`, expr);
 	},
 
 	_checkFuncLit(expr, scope) {
+		const savedSharedAlloc = this._sharedAllocOk;
+		this._sharedAllocOk = false;
+		try {
+			return this._checkFuncLitBody(expr, scope);
+		} finally {
+			this._sharedAllocOk = savedSharedAlloc;
+		}
+	},
+
+	_checkFuncLitBody(expr, scope) {
 		if (
 			(this.target === "wasm" || this.target === "both") &&
 			(expr.async || expr.isAsync)
@@ -431,7 +486,11 @@ export const expressionCheckMethods = {
 
 	_rangeCollTypeTuple(resolved, collType) {
 		if (isString(resolved)) return { kind: "tuple", types: [INT, RUNE] };
-		if (resolved?.kind === "slice" || resolved?.kind === "array")
+		if (
+			resolved?.kind === "slice" ||
+			resolved?.kind === "array" ||
+			resolved?.kind === "shared"
+		)
 			return { kind: "tuple", types: [INT, resolved.elem ?? ANY] };
 		if (resolved?.kind === "map")
 			return {
@@ -467,6 +526,9 @@ export const expressionCheckMethods = {
 					: null;
 				if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
 			}
+			expr._typeArgs = typeArgs;
+			if (expr.expr) expr.expr._typeArgs = typeArgs;
+			expr._genericFnType = baseType;
 			return this.instantiateGenericFunc(baseType, typeArgs);
 		}
 		// The parser's type-arg heuristic mistakes `xs[d.Field]` (uppercase field
@@ -546,6 +608,8 @@ export const expressionCheckMethods = {
 
 	checkCall(expr, scope) {
 		let fnType = this.checkExpr(expr.func, scope);
+		this._checkSharedAllocSite(expr, scope);
+		this._checkBoundaryCallInLoop(expr, scope);
 		if (fnType.kind === "builtin") {
 			const argTypes = expr.args.map((a, i) => {
 				// new(T) — first arg is a type name, not a value expression
@@ -576,12 +640,79 @@ export const expressionCheckMethods = {
 
 		this._checkCallArgs(fnType, argTypes, expr);
 
+		// Pseudo-generic stdlib helpers (maps.Keys, slices.Clone, ...) declare
+		// how their result derives from the first argument.
+		if (fnType._derivedReturn) {
+			const derived = this._derivedReturnType(fnType._derivedReturn, argTypes);
+			if (derived) return derived;
+		}
+
 		const ret = fnType.returns;
 		if (!ret || ret.length === 0) return VOID;
 		if (ret.length === 1) return ret[0];
 		return { kind: "tuple", types: ret };
 	},
 
+	// `shared.NewXxx(n)` allocates from a linear memory that is sized once at
+	// startup (no memory.grow → no detached TypedArray views on the JS side).
+	// Allocation is therefore only legal in package-level var initializers and
+	// init(), which both run inside the module start function.
+	// JS→WASM calls copy non-shared arguments across the boundary on every
+	// call. Inside a loop that dominates the per-iteration cost, so hint that
+	// the loop belongs on the WASM side (or the data in gofront/shared).
+	_checkBoundaryCallInLoop(expr, scope) {
+		if (this._loopDepth === 0 || this.target !== "js") return;
+		const fn = expr.func;
+		if (fn.kind !== "SelectorExpr" || fn.expr.kind !== "Ident") return;
+		const ns = scope.lookup(fn.expr.name);
+		if (ns?.kind !== "namespace" || ns._target !== "wasm") return;
+		const member = ns.members[fn.field];
+		if (member?.kind !== "func") return;
+		this.warn(
+			`'${fn.expr.name}.${fn.field}' crosses the JS→WASM boundary inside a loop`,
+			fn.expr, // CallExpr nodes carry no position; the callee Ident does
+			"hint: each call copies its arguments; move the loop into the wasm package or pass gofront/shared buffers",
+		);
+	},
+
+	_checkSharedAllocSite(expr, scope) {
+		const f = expr.func;
+		if (
+			f.kind !== "SelectorExpr" ||
+			f.expr.kind !== "Ident" ||
+			f.expr.name !== "shared" ||
+			!f.field.startsWith("New") ||
+			scope.lookup("shared") !== this.globals.lookup("shared")
+		)
+			return;
+		if (this._sharedAllocOk) return;
+		const why =
+			this.target === "wasm"
+				? "shared buffers are allocated once at startup"
+				: "shared buffers are allocated once at startup so the code stays portable to wasm packages";
+		this.err(
+			`shared.${f.field} must be called from a package-level var initializer or init(); ${why}`,
+			expr,
+		);
+	},
+
+	_derivedReturnType(mode, argTypes) {
+		const arg = argTypes[0];
+		const under = arg?.kind === "named" ? arg.underlying : arg;
+		switch (mode) {
+			case "arg0":
+				return under ? arg : null;
+			case "keysOfArg0":
+				return under?.key ? { kind: "slice", elem: under.key } : null;
+			case "valuesOfArg0": {
+				const v = under?.value ?? under?.elem;
+				return v ? { kind: "slice", elem: v } : null;
+			}
+			default:
+				return null;
+		}
+	},
+
 	_resolveGenericFnType(fnType, argTypes, expr, scope) {
 		const typeArgs = this.inferTypeArgs(fnType, argTypes);
 		if (!typeArgs) {
@@ -599,6 +730,10 @@ export const expressionCheckMethods = {
 				: null;
 			if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
 		}
+		expr._typeArgs = typeArgs;
+		if (expr.func) expr.func._typeArgs = typeArgs;
+		expr._genericFnType = fnType;
+		if (expr.func) expr.func._genericFnType = fnType;
 		return this.instantiateGenericFunc(fnType, typeArgs);
 	},
 
@@ -650,6 +785,11 @@ export const expressionCheckMethods = {
 		if (name === "len") {
 			const size = this._constLenFromType(argTypes[0]);
 			if (size != null) expr._constLen = size;
+		} else if (sharedInfo(argTypes[0])) {
+			this.err(
+				`cannot use cap() on ${typeStr(argTypes[0])}: shared buffers have a fixed size; use len()`,
+				expr,
+			);
 		}
 		return INT;
 	},

package/src/typechecker/index.js

@@ -45,6 +45,7 @@ export class TypeChecker {
 		this.types = new Map(); // named types
 		this.globals = new Scope();
 		this.errors = [];
+		this.warnings = []; // non-fatal diagnostics (e.g. boundary-call-in-loop hints)
 		this.target = "js";
 		this.pkgName = null;
 		this.blockers = new Map();
@@ -77,7 +78,8 @@ export class TypeChecker {
 	// Add an imported GoFront package as a qualified namespace.
 	// e.g. addPackageNamespace('utils', symbolsMap, typesMap)
 	// lets callers type-check `utils.Foo` via SelectorExpr.
-	addPackageNamespace(pkgName, symbols, types) {
+	// `target` is the imported package's compile target ("js"/"wasm"/"both").
+	addPackageNamespace(pkgName, symbols, types, target = null) {
 		const members = {};
 		for (const [name, type] of symbols) members[name] = type;
 		// _gofront: true marks this as a GoFront package — exported identifier rules apply
@@ -86,6 +88,7 @@ export class TypeChecker {
 			name: pkgName,
 			members,
 			_gofront: true,
+			_target: target,
 		});
 		for (const [name, type] of types) {
 			this.types.set(name, type);
@@ -171,6 +174,21 @@ export class TypeChecker {
 		return TAINTED_ANY; // tainted recovery type — suppresses downstream cascade errors
 	}
 
+	// Non-fatal diagnostic: formatted like an error but collected separately so
+	// the build still succeeds. The compiler prints these as warnings.
+	warn(msg, node, hint = null) {
+		const e = new TypeCheckError(
+			msg,
+			node,
+			this._currentFile,
+			this._currentSource,
+			hint,
+		);
+		// `log.warn` adds the "warning:" label, so strip the error one here:
+		// "Type error in main.go at line 3:5: msg" → "main.go at line 3:5: msg".
+		this.warnings.push(e.message.replace(/^Type error(?: in)?[: ]\s*/, ""));
+	}
+
 	_reportUnused(scope, node) {
 		for (const name of scope.unusedLocals()) {
 			this.err(`'${name}' declared and not used`, node);
@@ -524,6 +542,7 @@ export class TypeChecker {
 					? existing
 					: { kind: "named", name: decl.name };
 			named.underlying = underlying;
+			named._target = this.target;
 			named._generic = {
 				typeParams: typeParamTypes,
 				declNode: decl,
@@ -549,6 +568,7 @@ export class TypeChecker {
 				? existing
 				: { kind: "named", name: decl.name };
 		named.underlying = underlying;
+		named._target = this.target;
 		if (underlying.kind === "struct") {
 			underlying.name = decl.name;
 			underlying.methods = new Map();
@@ -777,7 +797,10 @@ export class TypeChecker {
 			inner.define(p.name, this.resolveTypeNode(p.type, inner));
 		}
 		const returnType = this._setupFuncReturnType(decl, inner, outer);
+		const savedSharedAlloc = this._sharedAllocOk;
+		this._sharedAllocOk = decl.name === "init";
 		this._runFuncBody(decl, inner, returnType);
+		this._sharedAllocOk = savedSharedAlloc;
 		this._checkMissingReturn(decl, returnType, "function");
 	}
 
@@ -870,6 +893,8 @@ export class TypeChecker {
 	}
 
 	checkVarDecl(decl, scope) {
+		const savedSharedAlloc = this._sharedAllocOk;
+		this._sharedAllocOk = scope === this.globals;
 		for (const spec of decl.decls) {
 			let type = spec.type ? this.resolveTypeNode(spec.type, scope) : null;
 			if (spec.value) {
@@ -883,6 +908,7 @@ export class TypeChecker {
 			if (!type) type = ANY;
 			for (const name of spec.names) scope.defineLocal(name, type);
 		}
+		this._sharedAllocOk = savedSharedAlloc;
 	}
 
 	checkConstDecl(decl, scope) {

package/src/typechecker/resolve.js

@@ -4,6 +4,7 @@
 import {
 	ANY,
 	BASIC_TYPES,
+	COMPARABLE,
 	defaultType,
 	isAny,
 	isTypedArraySlice,
@@ -12,6 +13,7 @@ import {
 	typedArrayConstructorForElem,
 	typeStr,
 	VOID,
+	WASM_STDLIB_MEMBERS,
 } from "./types.js";
 
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
@@ -81,8 +83,7 @@ export const resolveMethods = {
 		switch (node.kind) {
 			case "TypeName": {
 				if (BASIC_TYPES[node.name]) return BASIC_TYPES[node.name];
-				if (node.name === "comparable")
-					return { kind: "basic", name: "comparable" };
+				if (node.name === "comparable") return COMPARABLE;
 				if (scope) {
 					const fromScope = scope.lookup(node.name);
 					if (fromScope?.kind === "typeParam") return fromScope;
@@ -99,12 +100,16 @@ export const resolveMethods = {
 			case "GenericTypeName": {
 				const base = this.types.get(node.name);
 				if (!base) return this.err(`Unknown type '${node.name}'`, node);
-				if (base.kind === "named" && base._generic)
-					return this.instantiateGenericType(
+				if (base.kind === "named" && base._generic) {
+					const res = this.instantiateGenericType(
 						base._generic,
 						node.typeArgs,
 						scope,
 					);
+					node._typeArgs = res.typeArgs;
+					node._genericType = base;
+					return res;
+				}
 				return this.err(`Type '${node.name}' is not generic`, node);
 			}
 			case "TypeParam": {
@@ -266,12 +271,15 @@ export const resolveMethods = {
 		const typeArgs = typeArgNodes.map((n) => this.resolveTypeNode(n, scope));
 		for (let i = 0; i < generic.typeParams.length; i++)
 			map.set(generic.typeParams[i].name, typeArgs[i] ?? ANY);
+		// Resolve the declaration with its type params in scope (as typeParams,
+		// never as value symbols), then substitute the concrete arguments.
 		const typeScope = new Scope(this.globals);
-		for (const [name, type] of map) typeScope.define(name, type);
+		for (const tp of generic.typeParams) typeScope.define(tp.name, tp);
 		const underlying = this.resolveTypeNode(generic.declNode.type, typeScope);
 		const instantiated = this.substituteType(underlying, map);
 		if (instantiated.kind === "struct") {
 			instantiated.name = generic.declNode.name;
+			instantiated.typeArgs = typeArgs;
 			if (!instantiated.methods) instantiated.methods = new Map();
 			if (generic.methods) {
 				for (const [mName, mType] of generic.methods)
@@ -281,6 +289,7 @@ export const resolveMethods = {
 		return {
 			kind: "named",
 			name: generic.declNode.name,
+			typeArgs,
 			underlying: instantiated,
 		};
 	},
@@ -406,6 +415,9 @@ export const resolveMethods = {
 				return this._fieldTypeInterface(base, baseType, field, node);
 			case "namespace":
 				return this._fieldTypeNamespace(base, field, node);
+			case "shared":
+				if (base.methods?.has(field)) return base.methods.get(field);
+				return this.err(`No method '${field}' on ${typeStr(baseType)}`, node);
 			case "slice":
 				if (isTypedArraySlice(base)) {
 					return this._fieldTypeTypedArraySlice(base, baseType, field, node);
@@ -475,7 +487,24 @@ export const resolveMethods = {
 				`cannot refer to unexported name ${base.name}.${field}`,
 				node,
 			);
-		if (field in base.members) return base.members[field];
+		if (field in base.members) {
+			if (
+				(this.target === "wasm" || this.target === "both") &&
+				WASM_STDLIB_MEMBERS.has(base.name)
+			) {
+				const allowed = WASM_STDLIB_MEMBERS.get(base.name);
+				if (allowed && !allowed.has(field)) {
+					const name = `${base.name}.${field}`;
+					this.recordBlocker("unsupported stdlib member", name);
+					return this.err(
+						`'${name}' is not yet available in wasm packages`,
+						node,
+						"move this call to a JS package, or use a supported alternative",
+					);
+				}
+			}
+			return base.members[field];
+		}
 		return this.err(`No member '${field}' in namespace ${base.name}`, node);
 	},
 };

package/src/typechecker/statements.js

@@ -43,13 +43,6 @@ export const statementCheckMethods = {
 				this.checkExpr(stmt.expr, scope);
 				break;
 			case "DeferStmt":
-				if (this.target === "wasm" || this.target === "both") {
-					this.recordBlocker("defer statement");
-					this.err(
-						"'defer' is not yet supported in wasm packages (planned)",
-						stmt,
-					);
-				}
 				if (stmt.call.kind !== "CallExpr")
 					this.err("defer requires a function call", stmt.call);
 				this.checkExpr(stmt.call, scope);

package/src/typechecker/stdlib/core.js

@@ -540,6 +540,14 @@ export function setupCoreGlobals(globals, types) {
 		},
 	});
 
+	// Slice helpers that return a slice of the same type as their first argument.
+	const sameSlice = (params, extra = {}) => ({
+		kind: "func",
+		params,
+		returns: [ANY],
+		_derivedReturn: "arg0",
+		...extra,
+	});
 	globals.define("slices", {
 		kind: "namespace",
 		name: "slices",
@@ -558,26 +566,16 @@ export function setupCoreGlobals(globals, types) {
 			Min: { kind: "func", params: [ANY], returns: [ANY] },
 			MaxFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
 			MinFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
-			Clone: { kind: "func", params: [ANY], returns: [ANY] },
-			Compact: { kind: "func", params: [ANY], returns: [ANY] },
-			CompactFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+			Clone: sameSlice([ANY]),
+			Compact: sameSlice([ANY]),
+			CompactFunc: sameSlice([ANY, ANY]),
 			Concat: { kind: "func", params: [ANY], returns: [ANY], variadic: true },
-			Delete: { kind: "func", params: [ANY, INT, INT], returns: [ANY] },
-			DeleteFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
-			Insert: {
-				kind: "func",
-				params: [ANY, INT, ANY],
-				returns: [ANY],
-				variadic: true,
-			},
-			Replace: {
-				kind: "func",
-				params: [ANY, INT, INT, ANY],
-				returns: [ANY],
-				variadic: true,
-			},
-			Grow: { kind: "func", params: [ANY, INT], returns: [ANY] },
-			Clip: { kind: "func", params: [ANY], returns: [ANY] },
+			Delete: sameSlice([ANY, INT, INT]),
+			DeleteFunc: sameSlice([ANY, ANY]),
+			Insert: sameSlice([ANY, INT, ANY], { variadic: true }),
+			Replace: sameSlice([ANY, INT, INT, ANY], { variadic: true }),
+			Grow: sameSlice([ANY, INT]),
+			Clip: sameSlice([ANY]),
 		},
 	});
 

package/src/typechecker/stdlib/extended.js

@@ -160,9 +160,24 @@ export function setupExtendedGlobals(globals, types) {
 		kind: "namespace",
 		name: "maps",
 		members: {
-			Keys: { kind: "func", params: [ANY], returns: [ANY] },
-			Values: { kind: "func", params: [ANY], returns: [ANY] },
-			Clone: { kind: "func", params: [ANY], returns: [ANY] },
+			Keys: {
+				kind: "func",
+				params: [ANY],
+				returns: [ANY],
+				_derivedReturn: "keysOfArg0",
+			},
+			Values: {
+				kind: "func",
+				params: [ANY],
+				returns: [ANY],
+				_derivedReturn: "valuesOfArg0",
+			},
+			Clone: {
+				kind: "func",
+				params: [ANY],
+				returns: [ANY],
+				_derivedReturn: "arg0",
+			},
 			Copy: { kind: "func", params: [ANY, ANY], returns: [VOID] },
 			Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
 			EqualFunc: { kind: "func", params: [ANY, ANY, ANY], returns: [BOOL] },

package/src/typechecker/stdlib/shared.js

@@ -0,0 +1,53 @@
+// `gofront/shared` — fixed-size linear-memory buffers shared zero-copy between
+// wasm packages and JS. Each `shared.Xxx` is a named type whose underlying kind
+// is "shared" (not a slice): it supports indexing, len() and `.Subarray(lo, hi)`
+// but not slicing, append or implicit conversion to GC slices.
+
+import {
+	FLOAT32,
+	FLOAT64,
+	INT,
+	INT8,
+	INT16,
+	INT32,
+	UINT8,
+	UINT16,
+	UINT32,
+} from "../types.js";
+
+// key → [elem type, JS TypedArray ctor, byte size]
+export const SHARED_KINDS = {
+	Float32: { elem: FLOAT32, ctor: "Float32Array", bytes: 4, key: "f32" },
+	Float64: { elem: FLOAT64, ctor: "Float64Array", bytes: 8, key: "f64" },
+	Int8: { elem: INT8, ctor: "Int8Array", bytes: 1, key: "i8" },
+	Int16: { elem: INT16, ctor: "Int16Array", bytes: 2, key: "i16" },
+	Int32: { elem: INT32, ctor: "Int32Array", bytes: 4, key: "i32" },
+	Uint8: { elem: UINT8, ctor: "Uint8Array", bytes: 1, key: "u8" },
+	Uint16: { elem: UINT16, ctor: "Uint16Array", bytes: 2, key: "u16" },
+	Uint32: { elem: UINT32, ctor: "Uint32Array", bytes: 4, key: "u32" },
+};
+
+export function setupSharedGlobals(globals, types) {
+	const members = {};
+	for (const [name, info] of Object.entries(SHARED_KINDS)) {
+		const t = {
+			kind: "named",
+			name: `shared.${name}`,
+			underlying: { kind: "shared", elem: info.elem, shared: name },
+		};
+		t.underlying.methods = new Map([
+			["Subarray", { kind: "func", params: [INT, INT], returns: [t] }],
+		]);
+		types.set(t.name, t);
+		members[name] = t;
+		members[`New${name}`] = { kind: "func", params: [INT], returns: [t] };
+	}
+	globals.define("shared", { kind: "namespace", name: "shared", members });
+}
+
+// Returns the SHARED_KINDS entry for a (possibly named) shared type, or null.
+export function sharedInfo(t) {
+	const u = t?.kind === "named" ? t.underlying : t;
+	if (u?.kind !== "shared") return null;
+	return { name: u.shared, ...SHARED_KINDS[u.shared] };
+}

package/src/typechecker/stdlib.js

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