gofront 1.5.1 → 1.6.1

package/src/typechecker/stdlib/extended.js

@@ -8,8 +8,13 @@ import {
 	FLOAT32,
 	FLOAT64,
 	INT,
+	INT32,
+	INT64,
 	STRING,
 	UINT8,
+	UINT16,
+	UINT32,
+	UINT64,
 	VOID,
 } from "../types.js";
 
@@ -160,9 +165,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] },
@@ -236,15 +256,27 @@ export function setupExtendedGlobals(globals, types) {
 		["Write", { kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] }],
 		["String", { kind: "func", params: [], returns: [STRING] }],
 		["Len", { kind: "func", params: [], returns: [INT] }],
+		["Cap", { kind: "func", params: [], returns: [INT] }],
 		["Reset", { kind: "func", params: [], returns: [VOID] }],
 		["Grow", { kind: "func", params: [INT], returns: [VOID] }],
 	];
+	const STR_SLICE_T = { kind: "slice", elem: STRING };
 	const _makeBuilderType = (name, extra = []) => ({
 		kind: "named",
 		name,
 		underlying: {
 			kind: "struct",
-			fields: new Map(),
+			fields: new Map(
+				name === "strings.Builder"
+					? [
+							["_buf", STR_SLICE_T],
+							["_len", INT],
+							["_self", ANY],
+						]
+					: name === "bytes.Buffer"
+						? [["_buf", BYTE_SLICE_T]]
+						: [],
+			),
 			methods: new Map([..._builderBase, ...extra]),
 		},
 	});
@@ -257,9 +289,107 @@ export function setupExtendedGlobals(globals, types) {
 	types.set(
 		"bytes.Buffer",
 		_makeBuilderType("bytes.Buffer", [
+			["WriteRune", { kind: "func", params: [INT], returns: [INT, ERROR] }],
 			["Bytes", { kind: "func", params: [], returns: [BYTE_SLICE_T] }],
+			["Read", { kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] }],
 		]),
 	);
+	types.set("strings.Replacer", {
+		kind: "named",
+		name: "strings.Replacer",
+		underlying: {
+			kind: "struct",
+			fields: new Map([["_pairs", STR_SLICE_T]]),
+			methods: new Map([
+				["Replace", { kind: "func", params: [STRING], returns: [STRING] }],
+			]),
+		},
+	});
+	const _makeReaderType = (name, srcType, resetArgType = srcType) => ({
+		kind: "named",
+		name,
+		underlying: {
+			kind: "struct",
+			fields: new Map([
+				["_src", srcType],
+				["_pos", INT],
+			]),
+			methods: new Map([
+				[
+					"Read",
+					{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
+				],
+				["Len", { kind: "func", params: [], returns: [INT] }],
+				["Reset", { kind: "func", params: [resetArgType], returns: [VOID] }],
+			]),
+		},
+	});
+	types.set(
+		"strings.Reader",
+		_makeReaderType("strings.Reader", BYTE_SLICE_T, STRING),
+	);
+	types.set("bytes.Reader", _makeReaderType("bytes.Reader", BYTE_SLICE_T));
+	types.set("io.discard", {
+		kind: "named",
+		name: "io.discard",
+		underlying: {
+			kind: "struct",
+			fields: new Map(),
+			methods: new Map([
+				[
+					"Write",
+					{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
+				],
+				[
+					"WriteString",
+					{ kind: "func", params: [STRING], returns: [INT, ERROR] },
+				],
+			]),
+		},
+	});
+	const ioPkg = globals.lookup("io");
+	const IO_READER = ioPkg?.members?.Reader ?? {
+		kind: "interface",
+		name: "io.Reader",
+	};
+	types.set("io.LimitedReader", {
+		kind: "named",
+		name: "io.LimitedReader",
+		underlying: {
+			kind: "struct",
+			fields: new Map([
+				["R", IO_READER],
+				["N", INT64],
+			]),
+			methods: new Map([
+				[
+					"Read",
+					{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
+				],
+			]),
+		},
+	});
+	if (ioPkg?.members) {
+		ioPkg.members.LimitedReader = types.get("io.LimitedReader");
+	}
+	const stringsPkg = globals.lookup("strings");
+	if (stringsPkg?.members) {
+		stringsPkg.members.NewReader = {
+			kind: "func",
+			params: [STRING],
+			returns: [{ kind: "pointer", base: types.get("strings.Reader") }],
+		};
+		stringsPkg.members.Reader = types.get("strings.Reader");
+	}
+	const bytesPkg = globals.lookup("bytes");
+	if (bytesPkg?.members) {
+		bytesPkg.members.NewReader = {
+			kind: "func",
+			params: [BYTE_SLICE_T],
+			returns: [{ kind: "pointer", base: types.get("bytes.Reader") }],
+		};
+		bytesPkg.members.Reader = types.get("bytes.Reader");
+	}
 
 	globals.define("rand", {
 		kind: "namespace",
@@ -280,6 +410,25 @@ export function setupExtendedGlobals(globals, types) {
 				params: [INT],
 				returns: [{ kind: "slice", elem: INT }],
 			},
+			Read: {
+				kind: "func",
+				params: [{ kind: "slice", elem: UINT8 }],
+				returns: [INT, ERROR],
+			},
+			Reader: {
+				kind: "interface",
+				name: "io.Reader",
+				methods: new Map([
+					[
+						"Read",
+						{
+							kind: "func",
+							params: [{ kind: "slice", elem: UINT8 }],
+							returns: [INT, ERROR],
+						},
+					],
+				]),
+			},
 		},
 	});
 
@@ -325,9 +474,16 @@ export function setupExtendedGlobals(globals, types) {
 			IsAbs: { kind: "func", params: [STRING], returns: [BOOL] },
 			Split: { kind: "func", params: [STRING], returns: [STRING, STRING] },
 			Match: { kind: "func", params: [STRING, STRING], returns: [BOOL, ERROR] },
+			ErrBadPattern: ERROR,
 		},
 	});
 
+	globals.define("filepath", {
+		kind: "namespace",
+		name: "filepath",
+		members: globals.lookup("path").members,
+	});
+
 	const TESTING_T = {
 		kind: "named",
 		name: "testing.T",
@@ -386,6 +542,317 @@ export function setupExtendedGlobals(globals, types) {
 	});
 	types.set("testing.T", TESTING_T);
 
+	// ── sync ──────────────────────────────────────────────────────
+	const MUTEX_T = {
+		kind: "named",
+		name: "sync.Mutex",
+		underlying: { kind: "struct", fields: new Map([["state", INT32]]) },
+		methods: new Map([
+			["Lock", { kind: "func", params: [], returns: [VOID] }],
+			["Unlock", { kind: "func", params: [], returns: [VOID] }],
+			["TryLock", { kind: "func", params: [], returns: [BOOL] }],
+		]),
+	};
+	const RWMUTEX_T = {
+		kind: "named",
+		name: "sync.RWMutex",
+		underlying: { kind: "struct", fields: new Map([["state", INT32]]) },
+		methods: new Map([
+			["Lock", { kind: "func", params: [], returns: [VOID] }],
+			["Unlock", { kind: "func", params: [], returns: [VOID] }],
+			["RLock", { kind: "func", params: [], returns: [VOID] }],
+			["RUnlock", { kind: "func", params: [], returns: [VOID] }],
+			["TryLock", { kind: "func", params: [], returns: [BOOL] }],
+			["TryRLock", { kind: "func", params: [], returns: [BOOL] }],
+		]),
+	};
+	const ONCE_T = {
+		kind: "named",
+		name: "sync.Once",
+		underlying: { kind: "struct", fields: new Map([["done", UINT32]]) },
+		methods: new Map([
+			[
+				"Do",
+				{
+					kind: "func",
+					params: [{ kind: "func", params: [], returns: [VOID] }],
+					returns: [VOID],
+				},
+			],
+		]),
+	};
+	const WAITGROUP_T = {
+		kind: "named",
+		name: "sync.WaitGroup",
+		underlying: { kind: "struct", fields: new Map([["counter", INT]]) },
+		methods: new Map([
+			["Add", { kind: "func", params: [INT], returns: [VOID] }],
+			["Done", { kind: "func", params: [], returns: [VOID] }],
+			["Wait", { kind: "func", params: [], returns: [VOID] }],
+		]),
+	};
+	const LOCKER_T = {
+		kind: "interface",
+		name: "sync.Locker",
+		methods: new Map([
+			["Lock", { kind: "func", params: [], returns: [VOID] }],
+			["Unlock", { kind: "func", params: [], returns: [VOID] }],
+		]),
+	};
+	globals.define("sync", {
+		kind: "namespace",
+		name: "sync",
+		members: {
+			Mutex: MUTEX_T,
+			RWMutex: RWMUTEX_T,
+			Once: ONCE_T,
+			WaitGroup: WAITGROUP_T,
+			Locker: LOCKER_T,
+		},
+	});
+	types.set("sync.Mutex", MUTEX_T);
+	types.set("sync.RWMutex", RWMUTEX_T);
+	types.set("sync.Once", ONCE_T);
+	types.set("sync.WaitGroup", WAITGROUP_T);
+	types.set("sync.Locker", LOCKER_T);
+
+	// ── crypto/sha256 ─────────────────────────────────────────────
+	const BYTE_SLICE = { kind: "slice", elem: UINT8 };
+	const HASH_T = {
+		kind: "interface",
+		methods: new Map([
+			["Write", { kind: "func", params: [BYTE_SLICE], returns: [INT, ERROR] }],
+			["Sum", { kind: "func", params: [BYTE_SLICE], returns: [BYTE_SLICE] }],
+			["Reset", { kind: "func", params: [], returns: [VOID] }],
+			["Size", { kind: "func", params: [], returns: [INT] }],
+			["BlockSize", { kind: "func", params: [], returns: [INT] }],
+		]),
+	};
+	const SHA256_DIGEST_T = {
+		kind: "named",
+		name: "sha256.digest",
+		underlying: { kind: "struct", fields: new Map([["buf", BYTE_SLICE]]) },
+		methods: new Map([
+			["Write", { kind: "func", params: [BYTE_SLICE], returns: [INT, ERROR] }],
+			["Sum", { kind: "func", params: [BYTE_SLICE], returns: [BYTE_SLICE] }],
+			["Reset", { kind: "func", params: [], returns: [VOID] }],
+			["Size", { kind: "func", params: [], returns: [INT] }],
+			["BlockSize", { kind: "func", params: [], returns: [INT] }],
+		]),
+	};
+	globals.define("sha256", {
+		kind: "namespace",
+		name: "sha256",
+		members: {
+			Size: INT,
+			BlockSize: INT,
+			Sum256: {
+				kind: "func",
+				params: [BYTE_SLICE],
+				returns: [{ kind: "array", size: 32, elem: UINT8 }],
+			},
+			New: { kind: "func", params: [], returns: [HASH_T] },
+		},
+	});
+	types.set("hash.Hash", HASH_T);
+	types.set("sha256.digest", SHA256_DIGEST_T);
+	types.set("crypto/sha256.digest", SHA256_DIGEST_T);
+
+	// ── encoding/binary ───────────────────────────────────────────
+	const BYTE_ORDER_METHODS = [
+		["Uint16", { kind: "func", params: [BYTE_SLICE], returns: [UINT16] }],
+		["Uint32", { kind: "func", params: [BYTE_SLICE], returns: [UINT32] }],
+		["Uint64", { kind: "func", params: [BYTE_SLICE], returns: [UINT64] }],
+		[
+			"PutUint16",
+			{ kind: "func", params: [BYTE_SLICE, UINT16], returns: [VOID] },
+		],
+		[
+			"PutUint32",
+			{ kind: "func", params: [BYTE_SLICE, UINT32], returns: [VOID] },
+		],
+		[
+			"PutUint64",
+			{ kind: "func", params: [BYTE_SLICE, UINT64], returns: [VOID] },
+		],
+		["String", { kind: "func", params: [], returns: [STRING] }],
+	];
+	const BYTE_ORDER_T = {
+		kind: "interface",
+		methods: new Map(BYTE_ORDER_METHODS),
+	};
+	const LITTLE_ENDIAN_METHODS = new Map([
+		...BYTE_ORDER_METHODS,
+		[
+			"AppendUint16",
+			{ kind: "func", params: [BYTE_SLICE, UINT16], returns: [BYTE_SLICE] },
+		],
+		[
+			"AppendUint32",
+			{ kind: "func", params: [BYTE_SLICE, UINT32], returns: [BYTE_SLICE] },
+		],
+		[
+			"AppendUint64",
+			{ kind: "func", params: [BYTE_SLICE, UINT64], returns: [BYTE_SLICE] },
+		],
+	]);
+	const LITTLE_ENDIAN_T = {
+		kind: "named",
+		name: "binary.LittleEndian",
+		underlying: {
+			kind: "struct",
+			fields: new Map([["order", INT32]]),
+			methods: LITTLE_ENDIAN_METHODS,
+		},
+		methods: LITTLE_ENDIAN_METHODS,
+	};
+	const BIG_ENDIAN_METHODS = new Map([
+		...BYTE_ORDER_METHODS,
+		[
+			"AppendUint16",
+			{ kind: "func", params: [BYTE_SLICE, UINT16], returns: [BYTE_SLICE] },
+		],
+		[
+			"AppendUint32",
+			{ kind: "func", params: [BYTE_SLICE, UINT32], returns: [BYTE_SLICE] },
+		],
+		[
+			"AppendUint64",
+			{ kind: "func", params: [BYTE_SLICE, UINT64], returns: [BYTE_SLICE] },
+		],
+	]);
+	const BIG_ENDIAN_T = {
+		kind: "named",
+		name: "binary.BigEndian",
+		underlying: {
+			kind: "struct",
+			fields: new Map([["order", INT32]]),
+			methods: BIG_ENDIAN_METHODS,
+		},
+		methods: BIG_ENDIAN_METHODS,
+	};
+	globals.define("binary", {
+		kind: "namespace",
+		name: "binary",
+		members: {
+			ByteOrder: BYTE_ORDER_T,
+			LittleEndian: LITTLE_ENDIAN_T,
+			BigEndian: BIG_ENDIAN_T,
+			Read: {
+				kind: "func",
+				params: [ANY, BYTE_ORDER_T, ANY],
+				returns: [ERROR],
+			},
+			Write: {
+				kind: "func",
+				params: [ANY, BYTE_ORDER_T, ANY],
+				returns: [ERROR],
+			},
+			Size: { kind: "func", params: [ANY], returns: [INT] },
+			AppendUint16: {
+				kind: "func",
+				params: [BYTE_SLICE, UINT16],
+				returns: [BYTE_SLICE],
+			},
+			AppendUint32: {
+				kind: "func",
+				params: [BYTE_SLICE, UINT32],
+				returns: [BYTE_SLICE],
+			},
+			AppendUint64: {
+				kind: "func",
+				params: [BYTE_SLICE, UINT64],
+				returns: [BYTE_SLICE],
+			},
+		},
+	});
+	types.set("encoding/binary.ByteOrder", BYTE_ORDER_T);
+	types.set("binary.ByteOrder", BYTE_ORDER_T);
+	types.set("encoding/binary.LittleEndian", LITTLE_ENDIAN_T);
+	types.set("binary.LittleEndian", LITTLE_ENDIAN_T);
+	types.set("encoding/binary.BigEndian", BIG_ENDIAN_T);
+	types.set("binary.BigEndian", BIG_ENDIAN_T);
+
+	// ── encoding/hex ──────────────────────────────────────────────
+	globals.define("hex", {
+		kind: "namespace",
+		name: "hex",
+		members: {
+			EncodeToString: { kind: "func", params: [BYTE_SLICE], returns: [STRING] },
+			DecodeString: {
+				kind: "func",
+				params: [STRING],
+				returns: [BYTE_SLICE, ERROR],
+			},
+			Encode: {
+				kind: "func",
+				params: [BYTE_SLICE, BYTE_SLICE],
+				returns: [INT],
+			},
+			Decode: {
+				kind: "func",
+				params: [BYTE_SLICE, BYTE_SLICE],
+				returns: [INT, ERROR],
+			},
+			EncodedLen: { kind: "func", params: [INT], returns: [INT] },
+			DecodedLen: { kind: "func", params: [INT], returns: [INT] },
+			ErrLength: ERROR,
+		},
+	});
+
+	// ── encoding/base64 ───────────────────────────────────────────
+	const BASE64_ENCODING_METHODS = new Map([
+		[
+			"EncodeToString",
+			{ kind: "func", params: [BYTE_SLICE], returns: [STRING] },
+		],
+		[
+			"DecodeString",
+			{ kind: "func", params: [STRING], returns: [BYTE_SLICE, ERROR] },
+		],
+		[
+			"Encode",
+			{ kind: "func", params: [BYTE_SLICE, BYTE_SLICE], returns: [VOID] },
+		],
+		[
+			"Decode",
+			{ kind: "func", params: [BYTE_SLICE, BYTE_SLICE], returns: [INT, ERROR] },
+		],
+		["EncodedLen", { kind: "func", params: [INT], returns: [INT] }],
+		["DecodedLen", { kind: "func", params: [INT], returns: [INT] }],
+		["WithPadding", { kind: "func", params: [INT], returns: [ANY] }],
+	]);
+	const BASE64_ENCODING_T = {
+		kind: "named",
+		name: "base64.Encoding",
+		underlying: {
+			kind: "struct",
+			fields: new Map([["mode", INT32]]),
+			methods: BASE64_ENCODING_METHODS,
+		},
+		methods: BASE64_ENCODING_METHODS,
+	};
+	globals.define("base64", {
+		kind: "namespace",
+		name: "base64",
+		members: {
+			Encoding: BASE64_ENCODING_T,
+			StdEncoding: BASE64_ENCODING_T,
+			URLEncoding: BASE64_ENCODING_T,
+			RawStdEncoding: BASE64_ENCODING_T,
+			RawURLEncoding: BASE64_ENCODING_T,
+			NewEncoding: {
+				kind: "func",
+				params: [STRING],
+				returns: [BASE64_ENCODING_T],
+			},
+			StdPadding: INT,
+			NoPadding: INT,
+		},
+	});
+	types.set("encoding/base64.Encoding", BASE64_ENCODING_T);
+	types.set("base64.Encoding", BASE64_ENCODING_T);
+
 	for (const name of [
 		"append",
 		"len",

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);
 }