gofront 1.5.1 → 1.6.1

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;
@@ -96,16 +97,29 @@ export const resolveMethods = {
 				}
 				return this.err(`Unknown type '${node.name}'`, node);
 			}
-			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(
+			case "GenericTypeName":
+			case "InstantiationExpr":
+			case "IndexExpr": {
+				const name =
+					node.name ?? (node.expr?.kind === "Ident" ? node.expr.name : null);
+				const typeArgs = node.typeArgs ?? (node.index ? [node.index] : []);
+				const base = name
+					? this.types.get(name)
+					: node.expr
+						? this.resolveTypeNode(node.expr, scope)
+						: null;
+				if (!base) return this.err(`Unknown type '${name ?? "?"}'`, node);
+				if (base.kind === "named" && base._generic) {
+					const res = this.instantiateGenericType(
 						base._generic,
-						node.typeArgs,
+						typeArgs,
 						scope,
 					);
-				return this.err(`Type '${node.name}' is not generic`, node);
+					node._typeArgs = res.typeArgs;
+					node._genericType = base;
+					return res;
+				}
+				return this.err(`Type '${name ?? "?"}' is not generic`, node);
 			}
 			case "TypeParam": {
 				const constraint = node.constraint
@@ -266,12 +280,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,7 +298,9 @@ export const resolveMethods = {
 		return {
 			kind: "named",
 			name: generic.declNode.name,
+			typeArgs,
 			underlying: instantiated,
+			methods: instantiated.methods,
 		};
 	},
 
@@ -372,6 +391,14 @@ export const resolveMethods = {
 			const found = this.types.get(t.alias);
 			if (found) return found;
 		}
+		if (
+			t.kind === "named" &&
+			(!t.typeArgs || t.typeArgs.length === 0) &&
+			(!t.underlying || !t.methods)
+		) {
+			const found = this.types.get(t.name);
+			if (found) return found;
+		}
 		return t;
 	},
 
@@ -406,6 +433,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);
@@ -420,7 +450,19 @@ export const resolveMethods = {
 	},
 
 	_fieldTypeStruct(base, baseType, field, node) {
-		if (base.fields?.has(field)) return base.fields.get(field);
+		if (base.fields?.has(field)) {
+			if (
+				field.startsWith("_") &&
+				(baseType?.name?.startsWith("strings.") ||
+					baseType?.name?.startsWith("bytes."))
+			) {
+				return this.err(
+					`Cannot refer to unexported field '${field}' on ${typeStr(baseType)}`,
+					node,
+				);
+			}
+			return base.fields.get(field);
+		}
 		if (base.methods?.has(field)) return base.methods.get(field);
 		return this.err(`No field '${field}' on ${typeStr(baseType)}`, node);
 	},
@@ -475,7 +517,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);