gofront 1.3.4 → 1.3.6

package/src/typechecker/index.js

@@ -140,26 +140,7 @@ export class TypeChecker {
 	}
 
 	check(program) {
-		this._setCurrentFile(program);
-		// Pass 1: collect type declarations
-		for (const decl of program.decls) {
-			if (decl.kind === "TypeDecl") this.collectType(decl);
-		}
-		// Pass 2: collect function / method signatures
-		for (const decl of program.decls) {
-			if (decl.kind === "FuncDecl" || decl.kind === "MethodDecl") {
-				this.collectFunc(decl);
-			} else if (decl.kind === "TemplDecl") {
-				this._collectTemplDecl(decl);
-			}
-		}
-		// Pass 2.1: Promote embedded methods
-		this._promoteEmbeddedMethods();
-		// Pass 3: check bodies
-		for (const decl of program.decls) {
-			this.checkTopDecl(decl, this.globals);
-		}
-		return this.errors;
+		return this.checkAll([program]);
 	}
 
 	// Pre-declare a package-level var so other files can reference its name
@@ -196,11 +177,63 @@ export class TypeChecker {
 
 	_collectTypesPass(programs) {
 		for (const p of programs) {
-			this._setCurrentFile(p);
-			for (const d of p.decls) if (d.kind === "TypeDecl") this.collectType(d);
+			for (const d of p.decls) {
+				if (d.kind === "TypeDecl" && !d.isAlias && !this.types.has(d.name)) {
+					const placeholder = { kind: "named", name: d.name, underlying: null };
+					this.types.set(d.name, placeholder);
+					this.globals.define(d.name, placeholder);
+				}
+			}
+		}
+		const all = [];
+		for (const p of programs) {
+			for (const d of p.decls) if (d.kind === "TypeDecl") all.push({ p, d });
+		}
+		// Collect in dependency order so aliases, generics, embedded and by-value
+		// field types declared later (or in other files) are ready when needed.
+		let pending = all;
+		while (pending.length > 0) {
+			const pendingNames = new Map(pending.map((x) => [x.d.name, x.d]));
+			const ready = pending.filter(
+				(x) => !this._typeDeclBlocked(x.d, pendingNames),
+			);
+			const batch = ready.length > 0 ? ready : pending;
+			for (const { p, d } of batch) {
+				this._setCurrentFile(p);
+				this.collectType(d);
+			}
+			pending =
+				ready.length > 0 ? pending.filter((x) => !ready.includes(x)) : [];
 		}
 	}
 
+	_typeDeclBlocked(decl, pendingNames) {
+		const visit = (node, indirect) => {
+			if (!node || typeof node !== "object") return false;
+			if (Array.isArray(node)) return node.some((n) => visit(n, indirect));
+			if (
+				(node.kind === "TypeName" || node.kind === "GenericTypeName") &&
+				node.name !== decl.name
+			) {
+				const dep = pendingNames.get(node.name);
+				if (dep && (!indirect || dep.isAlias || dep.typeParams)) return true;
+			}
+			const nextIndirect =
+				indirect ||
+				[
+					"PointerType",
+					"SliceType",
+					"MapType",
+					"FuncType",
+					"ChanType",
+				].includes(node.kind);
+			return Object.keys(node).some(
+				(k) => !k.startsWith("_") && visit(node[k], nextIndirect),
+			);
+		};
+		return visit(decl.type, false);
+	}
+
 	_collectFuncsPass(programs) {
 		for (const p of programs) {
 			this._setCurrentFile(p);
@@ -274,14 +307,15 @@ export class TypeChecker {
 				return t;
 			});
 			const underlying = this.resolveTypeNode(decl.type, typeScope);
-			const named = {
-				kind: "named",
-				name: decl.name,
-				underlying,
-				_generic: {
-					typeParams: typeParamTypes,
-					declNode: decl,
-				},
+			const existing = this.types.get(decl.name);
+			const named =
+				existing?.kind === "named"
+					? existing
+					: { kind: "named", name: decl.name };
+			named.underlying = underlying;
+			named._generic = {
+				typeParams: typeParamTypes,
+				declNode: decl,
 			};
 			if (underlying.kind === "struct") {
 				underlying.name = decl.name;
@@ -298,7 +332,12 @@ export class TypeChecker {
 			this.globals.define(decl.name, underlying);
 			return;
 		}
-		const named = { kind: "named", name: decl.name, underlying };
+		const existing = this.types.get(decl.name);
+		const named =
+			existing?.kind === "named"
+				? existing
+				: { kind: "named", name: decl.name };
+		named.underlying = underlying;
 		if (underlying.kind === "struct") {
 			underlying.name = decl.name;
 			underlying.methods = new Map();
@@ -394,6 +433,7 @@ export class TypeChecker {
 	}
 
 	_attachMethod(decl, funcType) {
+		funcType._ptrRecv = Boolean(decl.recvPointer);
 		const recvNamedType = this.types.get(decl.recvType.name);
 		if (recvNamedType?._generic)
 			this._attachGenericMethod(recvNamedType, decl, funcType);

package/src/typechecker/resolve.js

@@ -411,6 +411,8 @@ export const resolveMethods = {
 	_fieldTypeInterface(base, baseType, field, node) {
 		if (base.methods?.has(field)) return base.methods.get(field);
 		if (base.fields?.has(field)) return base.fields.get(field);
+		if (base._excluded?.has(field))
+			return this.err(`No member '${field}' on ${typeStr(baseType)}`, node);
 		if (base._isOpen) return ANY;
 		return this.err(`No method '${field}' on ${typeStr(baseType)}`, node);
 	},

package/src/typechecker/statements.js

@@ -148,8 +148,17 @@ export const statementCheckMethods = {
 		for (let i = 0; i < lhsTypes.length; i++) {
 			if (stmt.lhs[i]?.kind === "Ident" && stmt.lhs[i]?.name === "_") continue;
 			const r = rhsFlat[i] ?? ANY;
-			if (!isAny(lhsTypes[i]) && !isAny(r))
+			if (stmt.rhs.length === lhsTypes.length && lhsTypes[i] && r)
+				this._markIfaceBox(
+					this.resolveType(lhsTypes[i]),
+					this.resolveType(r),
+					stmt.rhs[i],
+				);
+			if (!isAny(lhsTypes[i]) && !isAny(r)) {
+				this._skipIfaceMark = true;
 				this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
+				this._skipIfaceMark = false;
+			}
 		}
 	},
 

package/src/typechecker/stdlib/web.js

@@ -23,6 +23,25 @@ const func = (params, returns = [VOID], variadic = false) => ({
 	variadic,
 });
 
+// Last parameter is optional (modelled as variadic).
+const optLast = (params, returns = [VOID]) => func(params, returns, true);
+
+const WEBGL2_ONLY_CONSTANTS = new Set([
+	"UNIFORM_BUFFER",
+	"HALF_FLOAT",
+	"RGBA8",
+	"RGBA32F",
+]);
+
+const WEBGL2_ONLY_METHODS = new Set([
+	"VertexAttribIPointer",
+	"DrawArraysInstanced",
+	"DrawElementsInstanced",
+	"CreateVertexArray",
+	"BindVertexArray",
+	"DeleteVertexArray",
+]);
+
 const WEBGL_CONSTANTS_LIST = {
 	ARRAY_BUFFER: 0x8892,
 	ELEMENT_ARRAY_BUFFER: 0x8893,
@@ -113,7 +132,7 @@ function buildArrayBufferType() {
 		methods,
 	};
 	named.underlying = iface;
-	methods.set("slice", func([INT, INT], [named]));
+	methods.set("slice", optLast([INT, INT], [named]));
 	return named;
 }
 
@@ -126,20 +145,20 @@ function buildDataViewType(arrayBufferType) {
 	const methods = new Map([
 		["getInt8", func([INT], [INT8])],
 		["getUint8", func([INT], [UINT8])],
-		["getInt16", func([INT, BOOL], [INT16])],
-		["getUint16", func([INT, BOOL], [UINT16])],
-		["getInt32", func([INT, BOOL], [INT32])],
-		["getUint32", func([INT, BOOL], [UINT32])],
-		["getFloat32", func([INT, BOOL], [FLOAT32])],
-		["getFloat64", func([INT, BOOL], [FLOAT64])],
+		["getInt16", optLast([INT, BOOL], [INT16])],
+		["getUint16", optLast([INT, BOOL], [UINT16])],
+		["getInt32", optLast([INT, BOOL], [INT32])],
+		["getUint32", optLast([INT, BOOL], [UINT32])],
+		["getFloat32", optLast([INT, BOOL], [FLOAT32])],
+		["getFloat64", optLast([INT, BOOL], [FLOAT64])],
 		["setInt8", func([INT, INT8])],
 		["setUint8", func([INT, UINT8])],
-		["setInt16", func([INT, INT16, BOOL])],
-		["setUint16", func([INT, UINT16, BOOL])],
-		["setInt32", func([INT, INT32, BOOL])],
-		["setUint32", func([INT, UINT32, BOOL])],
-		["setFloat32", func([INT, FLOAT32, BOOL])],
-		["setFloat64", func([INT, FLOAT64, BOOL])],
+		["setInt16", optLast([INT, INT16, BOOL])],
+		["setUint16", optLast([INT, UINT16, BOOL])],
+		["setInt32", optLast([INT, INT32, BOOL])],
+		["setUint32", optLast([INT, UINT32, BOOL])],
+		["setFloat32", optLast([INT, FLOAT32, BOOL])],
+		["setFloat64", optLast([INT, FLOAT64, BOOL])],
 	]);
 	const named = { kind: "named", name: "DataView", underlying: null };
 	named.underlying = { kind: "interface", name: "DataView", fields, methods };
@@ -164,15 +183,16 @@ function buildTypedArrayType(name, elemType, arrayBufferType) {
 		_isTypedArray: true,
 	};
 	named.underlying = iface;
-	methods.set("subarray", func([INT, INT], [named]));
-	methods.set("slice", func([INT, INT], [named]));
-	methods.set("set", func([ANY, INT], [VOID]));
+	methods.set("subarray", optLast([INT, INT], [named]));
+	methods.set("slice", optLast([INT, INT], [named]));
+	methods.set("set", optLast([ANY, INT], [VOID]));
 	return named;
 }
 
-function createWebGLMethods() {
+function createWebGLMethods(isWebGL2) {
 	const methods = new Map();
 	const add = (name, fn) => {
+		if (!isWebGL2 && WEBGL2_ONLY_METHODS.has(name)) return;
 		methods.set(name, fn);
 		const camel = name[0].toLowerCase() + name.slice(1);
 		if (camel !== name) methods.set(camel, fn);
@@ -296,7 +316,7 @@ function createWebGPUMethods() {
 	addDev("CreateShaderModule", func([ANY], [ANY]));
 	addDev("CreateRenderPipeline", func([ANY], [ANY]));
 	addDev("CreateComputePipeline", func([ANY], [ANY]));
-	addDev("CreateCommandEncoder", func([ANY], [ANY]));
+	addDev("CreateCommandEncoder", optLast([ANY], [ANY]));
 	addDev("CreateBindGroup", func([ANY], [ANY]));
 	addDev("CreateBindGroupLayout", func([ANY], [ANY]));
 	addDev("CreatePipelineLayout", func([ANY], [ANY]));
@@ -307,7 +327,7 @@ function createWebGPUMethods() {
 		const camel = name[0].toLowerCase() + name.slice(1);
 		if (camel !== name) adapterMethods.set(camel, fn);
 	};
-	addAdapt("RequestDevice", func([ANY], [ANY]));
+	addAdapt("RequestDevice", optLast([ANY], [ANY]));
 
 	return { queueMethods, deviceMethods, adapterMethods };
 }
@@ -339,21 +359,29 @@ export function setupWebGlobals(globals, types) {
 	}
 
 	// WebGL constants map
-	const constFields = new Map();
+	const constFields2 = new Map();
 	for (const [k] of Object.entries(WEBGL_CONSTANTS_LIST)) {
-		constFields.set(k, INT);
+		constFields2.set(k, INT);
+	}
+	const constFields1 = new Map(
+		[...constFields2].filter(([k]) => !WEBGL2_ONLY_CONSTANTS.has(k)),
+	);
+	const webgl2Only = new Set(WEBGL2_ONLY_CONSTANTS);
+	for (const m of WEBGL2_ONLY_METHODS) {
+		webgl2Only.add(m);
+		webgl2Only.add(m[0].toLowerCase() + m.slice(1));
 	}
 
-	const webglMethods = createWebGLMethods();
 	const webglContext = {
 		kind: "named",
 		name: "WebGLRenderingContext",
 		underlying: {
 			kind: "interface",
 			name: "WebGLRenderingContext",
-			fields: constFields,
-			methods: webglMethods,
+			fields: constFields1,
+			methods: createWebGLMethods(false),
 			_isOpen: true,
+			_excluded: webgl2Only,
 		},
 	};
 	const webgl2Context = {
@@ -362,8 +390,8 @@ export function setupWebGlobals(globals, types) {
 		underlying: {
 			kind: "interface",
 			name: "WebGL2RenderingContext",
-			fields: constFields,
-			methods: webglMethods,
+			fields: constFields2,
+			methods: createWebGLMethods(true),
 			_isOpen: true,
 		},
 	};

package/src/typechecker/types.js

@@ -55,7 +55,7 @@ export const UINT16 = { kind: "basic", name: "uint16" };
 export const UINT32 = { kind: "basic", name: "uint32" };
 export const UINT64 = { kind: "basic", name: "uint64" };
 export const UINTPTR = { kind: "basic", name: "uintptr" };
-export const RUNE = INT;
+export const RUNE = INT32;
 export const FLOAT32 = { kind: "basic", name: "float32" };
 export const FLOAT64 = { kind: "basic", name: "float64" };
 export const STRING = { kind: "basic", name: "string" };
@@ -149,9 +149,9 @@ export const isString = makeBasicPredicate("string");
 export const isBool = makeBasicPredicate("bool");
 
 // ── TypedArray mappings ──────────────────────────────────────
+// []float64 deliberately stays a plain Array for JSON / JS-library interop.
 export const TYPED_ARRAY_CONSTRUCTORS = {
 	float32: "Float32Array",
-	float64: "Float64Array",
 	uint8: "Uint8Array",
 	byte: "Uint8Array",
 	int8: "Int8Array",
@@ -159,6 +159,7 @@ export const TYPED_ARRAY_CONSTRUCTORS = {
 	int16: "Int16Array",
 	uint32: "Uint32Array",
 	int32: "Int32Array",
+	rune: "Int32Array",
 };
 
 export function typedArrayConstructorForElem(elemType) {

package/src/vendor.js

@@ -227,9 +227,12 @@ export async function loadNodePolyfillsPlugin(projectRoot, customPlugin) {
 	if (!info) return null;
 	try {
 		const mod = await import(pathToFileURL(info.path).href);
-		const fn =
-			mod.nodePolyfills || mod.default?.nodePolyfills || mod.default || mod;
-		return typeof fn === "function" ? fn() : mod;
+		const fn = [
+			mod.nodePolyfills,
+			mod.default?.nodePolyfills,
+			mod.default,
+		].find((f) => typeof f === "function");
+		return fn ? fn() : null;
 	} catch {
 		return null;
 	}
@@ -339,10 +342,12 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 		options.nodePolyfillsPlugin ??
 		bundlerInfo.nodePolyfillsPlugin ??
 		(options.nodePolyfills === false ? null : undefined);
-	const polyfillPlugin = await loadNodePolyfillsPlugin(
-		projectRoot,
-		customPlugin,
-	);
+	// The polyfill plugin is a Rolldown plugin; esbuild cannot use it.
+	const supportsPlugins =
+		typeof bundlerInfo.bundle === "function" || bundlerInfo.name === "rolldown";
+	const polyfillPlugin = supportsPlugins
+		? await loadNodePolyfillsPlugin(projectRoot, customPlugin)
+		: null;
 
 	if (typeof bundlerInfo.bundle === "function") {
 		try {