gofront 1.6.0 → 1.7.0

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";
 
@@ -251,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]),
 		},
 	});
@@ -272,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",
@@ -295,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],
+						},
+					],
+				]),
+			},
 		},
 	});
 
@@ -340,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",
@@ -401,6 +542,354 @@ 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);
+
+	// ── encoding/json ─────────────────────────────────────────────
+	const RAW_MESSAGE_T = {
+		kind: "named",
+		name: "json.RawMessage",
+		underlying: BYTE_SLICE,
+		methods: new Map(),
+	};
+	globals.define("json", {
+		kind: "namespace",
+		name: "json",
+		members: {
+			Marshal: {
+				kind: "func",
+				params: [ANY],
+				returns: [BYTE_SLICE, ERROR],
+			},
+			MarshalIndent: {
+				kind: "func",
+				params: [ANY, STRING, STRING],
+				returns: [BYTE_SLICE, ERROR],
+			},
+			Unmarshal: {
+				kind: "func",
+				params: [BYTE_SLICE, ANY],
+				returns: [ERROR],
+			},
+			Valid: {
+				kind: "func",
+				params: [BYTE_SLICE],
+				returns: [BOOL],
+			},
+			RawMessage: RAW_MESSAGE_T,
+		},
+	});
+	types.set("encoding/json.RawMessage", RAW_MESSAGE_T);
+	types.set("json.RawMessage", RAW_MESSAGE_T);
+
 	for (const name of [
 		"append",
 		"len",

package/src/typechecker/stdlib/simd.js

@@ -0,0 +1,73 @@
+// src/typechecker/stdlib/simd.js
+// `gofront/simd` — WebAssembly SIMD types and vector operations.
+//
+// F32x4 is a 128-bit 4-wide float32 vector with Go value semantics:
+// - Lowered to WASM v128 in wasm packages.
+// - Lowered to a frozen 4-number array with Math.fround in js packages.
+
+import { FLOAT32, INT } from "../types.js";
+
+export function setupSimdGlobals(globals, types) {
+	const f32x4Type = {
+		kind: "named",
+		name: "simd.F32x4",
+		underlying: {
+			kind: "simd",
+			simd: "F32x4",
+			elem: FLOAT32,
+			lanes: 4,
+		},
+	};
+
+	f32x4Type.underlying.methods = new Map([
+		["Add", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Sub", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Mul", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Div", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Min", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Max", { kind: "func", params: [f32x4Type], returns: [f32x4Type] }],
+		["Dot3", { kind: "func", params: [f32x4Type], returns: [FLOAT32] }],
+		["Dot4", { kind: "func", params: [f32x4Type], returns: [FLOAT32] }],
+		["Lane", { kind: "func", params: [INT], returns: [FLOAT32] }],
+		[
+			"WithLane",
+			{ kind: "func", params: [INT, FLOAT32], returns: [f32x4Type] },
+		],
+		["Splat", { kind: "func", params: [FLOAT32], returns: [f32x4Type] }],
+	]);
+
+	types.set("simd.F32x4", f32x4Type);
+	types.set("F32x4", f32x4Type);
+
+	const sharedFloat32 = types.get("shared.Float32") ?? {
+		kind: "named",
+		name: "shared.Float32",
+		underlying: { kind: "shared", elem: FLOAT32, shared: "Float32" },
+	};
+
+	const members = {
+		F32x4: f32x4Type,
+		NewF32x4: {
+			kind: "func",
+			params: [FLOAT32, FLOAT32, FLOAT32, FLOAT32],
+			returns: [f32x4Type],
+		},
+		Splat: {
+			kind: "func",
+			params: [FLOAT32],
+			returns: [f32x4Type],
+		},
+		LoadF32x4: {
+			kind: "func",
+			params: [sharedFloat32, INT],
+			returns: [f32x4Type],
+		},
+		StoreF32x4: {
+			kind: "func",
+			params: [sharedFloat32, INT, f32x4Type],
+			returns: [],
+		},
+	};
+
+	globals.define("simd", { kind: "namespace", name: "simd", members });
+}

package/src/typechecker/stdlib.js

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