gofront 1.5.1 → 1.6.1

package/src/typechecker/assignability.js

@@ -1,6 +1,7 @@
 // Assignability, binary result types, and interface satisfaction.
 // Installed as a mixin on TypeChecker.prototype.
 
+import { sharedInfo } from "./stdlib/shared.js";
 import {
 	ANY,
 	BOOL,
@@ -159,6 +160,7 @@ export const assignabilityMethods = {
 		target = this.resolveType(target);
 		source = this.resolveType(source);
 		this._markIfaceBox(target, source, node);
+		this._checkWasmIfaceProvider(target, source, node);
 		if (this._assertAssignableEarlyReturn(target, source)) return;
 		if (isPointer(target) && isPointer(source)) {
 			this.assertAssignable(
@@ -180,24 +182,99 @@ export const assignabilityMethods = {
 	// Tags struct values / struct pointers flowing into an interface so codegen can
 	// tell `T` from `*T` at runtime (both compile to the same class instance).
 	_markIfaceBox(target, source, node) {
-		if (this._skipIfaceMark) return;
-		if (!node || typeof node !== "object" || !target || !source) return;
+		if (
+			this._skipIfaceMark ||
+			!node ||
+			typeof node !== "object" ||
+			!target ||
+			!source
+		)
+			return;
 		if (target.kind === "typeParam") return;
 		const tBase = this.resolveType(
 			target.kind === "named" ? target.underlying : target,
 		);
 		if (!isAny(target) && tBase?.kind !== "interface") return;
-		const structOf = (t) => {
-			const r = this.resolveType(t);
-			const b = r?.kind === "named" ? this.resolveType(r.underlying) : r;
-			return b?.kind === "struct";
-		};
 		const sBase = this.resolveType(
 			source.kind === "named" ? source.underlying : source,
 		);
-		if (sBase?.kind === "struct") node._ifaceBox = "value";
-		else if (sBase?.kind === "pointer" && structOf(sBase.base))
-			node._ifaceBox = "ptr";
+		const info = this._classifyIfaceBox(sBase);
+		if (!info) return;
+		node._ifaceBox = info.box;
+		if (info.ptrFields) node._ifacePtrFields = info.ptrFields;
+	},
+
+	_getStructPtrFields(st, prefix = "", seen = new Set()) {
+		if (st?.kind !== "struct" || !st?.fields) return [];
+		if (seen.has(st)) return [];
+		const nextSeen = new Set(seen);
+		nextSeen.add(st);
+		const ptrs = [];
+		for (const [fname, ftype] of st.fields.entries()) {
+			const full = prefix ? `${prefix}.${fname}` : fname;
+			const rf = this.resolveType(ftype);
+			const bf = rf?.kind === "named" ? this.resolveType(rf.underlying) : rf;
+			if (isPointer(bf)) {
+				ptrs.push(full);
+			} else if (bf?.kind === "struct") {
+				ptrs.push(...this._getStructPtrFields(bf, full, nextSeen));
+			}
+		}
+		return ptrs;
+	},
+
+	_classifyIfaceBox(sBase) {
+		if (sBase?.kind === "struct") {
+			const pf = this._getStructPtrFields(sBase);
+			return { box: "value", ptrFields: pf.length > 0 ? pf : null };
+		}
+		if (sBase?.kind === "pointer") {
+			const st = this.resolveType(
+				sBase.base?.kind === "named" ? sBase.base.underlying : sBase.base,
+			);
+			if (st?.kind === "struct") {
+				const pf = this._getStructPtrFields(st);
+				return { box: "ptr", ptrFields: pf.length > 0 ? pf : null };
+			}
+			return null;
+		}
+		if (sBase?.kind === "map") {
+			const valType = this.resolveType(sBase.value ?? sBase.val ?? sBase.elem);
+			const keyType = this.resolveType(sBase.key);
+			return {
+				box: isPointer(valType) || isPointer(keyType) ? "ptr_map" : "map",
+			};
+		}
+		if (sBase?.kind === "slice") {
+			const elemType = this.resolveType(sBase.elem);
+			if (isPointer(elemType)) return { box: "ptr_slice" };
+			const elemBase =
+				elemType?.kind === "named"
+					? this.resolveType(elemType.underlying)
+					: elemType;
+			const pf =
+				elemBase?.kind === "struct" ? this._getStructPtrFields(elemBase) : [];
+			return pf.length > 0 ? { box: "slice", ptrFields: pf } : null;
+		}
+		return null;
+	},
+
+	// A js package cannot provide an implementation of a wasm interface: the
+	// value would cross into wasm, and JS-implemented proxies are not supported.
+	_checkWasmIfaceProvider(target, source, node) {
+		if (this.target !== "js" || target?.kind !== "named") return;
+		if (target._target !== "wasm" || !source) return;
+		const iface = this.resolveType(target.underlying);
+		if (iface?.kind !== "interface" || !(iface.methods?.size > 0)) return;
+		const ptr = source.kind === "pointer";
+		const src = ptr ? this.resolveType(source.base) : source;
+		if (src?.kind !== "named" || src._target === "wasm") return;
+		if (this.resolveType(src.underlying)?.kind === "interface") return;
+		if (!this.implements(source, iface, node)) return;
+		this.err(
+			`type '${ptr ? "*" : ""}${src.name}' (${src._target ?? "js"}) cannot implement wasm interface '${target.name}' across the boundary; implement it in a wasm package or pass a func callback`,
+			node,
+		);
 	},
 
 	_assertAssignableEarlyReturn(target, source) {
@@ -222,6 +299,23 @@ export const assignabilityMethods = {
 				);
 			return;
 		}
+		const sBase = this.resolveType(
+			source.kind === "named" ? source.underlying : source,
+		);
+		if (sharedInfo(source) && tBase?.kind === "slice") {
+			this.err(
+				`cannot use ${typeStr(source)} as ${typeStr(target)}: a linear-memory buffer cannot be passed as a GC slice without an explicit copy`,
+				node,
+			);
+			return;
+		}
+		if (tBase?.kind === "shared" && sBase?.kind === "slice") {
+			this.err(
+				`cannot use ${typeStr(source)} as ${typeStr(target)}: a GC slice cannot be used as a shared buffer; copy its elements into one allocated with shared.New${tBase.shared}`,
+				node,
+			);
+			return;
+		}
 		this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
 	},
 
@@ -334,18 +428,30 @@ export const assignabilityMethods = {
 		return true;
 	},
 
+	_unpackReturns(rList) {
+		if (
+			rList.length === 1 &&
+			(rList[0]?.kind === "tuple" || rList[0]?.kind === "TupleType") &&
+			rList[0].types
+		) {
+			return rList[0].types;
+		}
+		return rList;
+	},
+
 	_implementsMethod(required, actual) {
 		if (!actual) return false;
 		const rp = required.params ?? [],
 			ap = actual.params ?? [];
-		const rr = required.returns ?? [],
-			ar = actual.returns ?? [];
+		const rr = this._unpackReturns(required.returns ?? []),
+			ar = this._unpackReturns(actual.returns ?? []);
 		if (!this._sigParamsMatch(rp, ap)) return false;
 		if (!!required.variadic !== !!actual.variadic) return false;
 		return this._sigParamsMatch(rr, ar);
 	},
 
 	implements(srcType, iface, _node) {
+		const isPtr = srcType?.kind === "pointer";
 		// *T has the full method set of T (value + pointer receivers).
 		if (srcType?.kind === "pointer") srcType = this.resolveType(srcType.base);
 		let base = srcType.kind === "named" ? srcType.underlying : srcType;
@@ -360,13 +466,16 @@ export const assignabilityMethods = {
 		}
 		const methodMap =
 			base?.kind === "struct"
-				? base.methods
+				? base.methods || srcType.methods
 				: srcType.kind === "named"
 					? srcType.methods
 					: null;
 		if (!methodMap) return false;
 		for (const [name, required] of iface.methods) {
-			if (!this._implementsMethod(required, methodMap.get(name))) return false;
+			const actual = methodMap.get(name);
+			if (!actual) return false;
+			if (!isPtr && actual._ptrRecv) return false;
+			if (!this._implementsMethod(required, actual)) return false;
 		}
 		return true;
 	},

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;
@@ -258,6 +266,16 @@ export const expressionCheckMethods = {
 			if (this._isStructOrNamedMethod(baseType, base, expr.field))
 				expr._isMethodValue = true;
 		}
+		if (
+			baseType?.kind === "namespace" &&
+			this.types.has(`${baseType.name}.${expr.field}`) &&
+			!(
+				baseType.name === "binary" &&
+				(expr.field === "LittleEndian" || expr.field === "BigEndian")
+			)
+		) {
+			expr._isTypeRef = true;
+		}
 		return ft;
 	},
 
@@ -291,10 +309,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 +355,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)
@@ -409,6 +474,81 @@ export const expressionCheckMethods = {
 		return targetType;
 	},
 
+	_checkConversionValidity(srcType, targetType, expr) {
+		if (!srcType || !targetType || isAny(srcType) || isAny(targetType)) return;
+		const srcResolved = srcType.kind === "named" ? srcType.underlying : srcType;
+		const tgtResolved =
+			targetType.kind === "named" ? targetType.underlying : targetType;
+
+		if (isNumeric(targetType) && isComplex(srcType)) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)} (use real() or imag())`,
+				expr,
+			);
+			return;
+		}
+		if (isComplex(targetType) && !isComplexOrNumeric(srcType)) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+				expr,
+			);
+			return;
+		}
+		if (this._isMutualArraySlice(tgtResolved, srcResolved)) {
+			this._checkElemTypeCompatible(
+				tgtResolved.elem,
+				srcResolved.elem,
+				srcType,
+				targetType,
+				expr,
+			);
+			return;
+		}
+		if (this._isInvalidArrayConv(tgtResolved, srcResolved, srcType)) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+				expr,
+			);
+			return;
+		}
+		if (typeStr(srcResolved) === typeStr(tgtResolved)) return;
+		if (isNumeric(srcResolved) && isNumeric(tgtResolved)) return;
+		if (
+			isString(srcResolved) &&
+			tgtResolved?.kind === "slice" &&
+			(tgtResolved.elem?.name === "byte" ||
+				tgtResolved.elem?.name === "rune" ||
+				tgtResolved.elem?.name === "uint8" ||
+				tgtResolved.elem?.name === "int32")
+		)
+			return;
+		if (
+			isString(tgtResolved) &&
+			(isNumeric(srcResolved) ||
+				(srcResolved?.kind === "slice" &&
+					(srcResolved.elem?.name === "byte" ||
+						srcResolved.elem?.name === "rune" ||
+						srcResolved.elem?.name === "uint8" ||
+						srcResolved.elem?.name === "int32")))
+		)
+			return;
+		if (srcResolved?.kind === "pointer" && tgtResolved?.kind === "pointer") {
+			const sBase =
+				srcResolved.base?.kind === "named"
+					? srcResolved.base.underlying
+					: srcResolved.base;
+			const tBase =
+				tgtResolved.base?.kind === "named"
+					? tgtResolved.base.underlying
+					: tgtResolved.base;
+			if (typeStr(sBase) === typeStr(tBase)) return;
+		}
+		this.err(
+			`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+			expr,
+		);
+	},
+
 	_checkTypeAssertExpr(expr, scope) {
 		const srcType = this.checkExpr(expr.expr, scope);
 		const targetType = this.resolveTypeNode(expr.type, scope);
@@ -431,7 +571,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 +611,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 +693,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
@@ -565,6 +714,14 @@ export const expressionCheckMethods = {
 		if (fnType.kind === "named" && expr.func._isTypeRef) {
 			expr._isTypeConversion = true;
 			expr._conversionTargetType = fnType;
+			if (expr.args.length !== 1) {
+				return this.err(
+					`cannot convert ${expr.args.length} arguments to type ${typeStr(fnType)}`,
+					expr,
+				);
+			}
+			const argType = argTypes[0];
+			this._checkConversionValidity(argType, fnType, expr);
 			return fnType;
 		}
 
@@ -576,12 +733,81 @@ 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 "elemOfArg0":
+				return under?.elem ?? 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 +825,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);
 	},
 
@@ -620,13 +850,18 @@ export const expressionCheckMethods = {
 
 	_checkCallArgs(fnType, argTypes, expr) {
 		this._checkArgCount(fnType, argTypes, expr);
-		for (let i = 0; i < fnType.params.length && i < argTypes.length; i++) {
+		const maxLen = fnType.variadic
+			? argTypes.length
+			: Math.min(fnType.params.length, argTypes.length);
+		for (let i = 0; i < maxLen; i++) {
 			const paramIdx =
 				fnType.variadic && i >= fnType.params.length - 1
 					? fnType.params.length - 1
 					: i;
 			if (expr.args[i]?._spread) continue;
-			this.assertAssignable(fnType.params[paramIdx], argTypes[i], expr.args[i]);
+			const targetParam = fnType.params[paramIdx];
+			const node = expr._multiForward ? null : expr.args[i];
+			this.assertAssignable(targetParam, argTypes[i], node);
 		}
 	},
 
@@ -650,6 +885,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) {