gofront 1.7.0 → 1.8.0

package/src/typechecker/stdlib/extended.js

@@ -165,18 +165,6 @@ export function setupExtendedGlobals(globals, types) {
 		kind: "namespace",
 		name: "maps",
 		members: {
-			Keys: {
-				kind: "func",
-				params: [ANY],
-				returns: [ANY],
-				_derivedReturn: "keysOfArg0",
-			},
-			Values: {
-				kind: "func",
-				params: [ANY],
-				returns: [ANY],
-				_derivedReturn: "valuesOfArg0",
-			},
 			Clone: {
 				kind: "func",
 				params: [ANY],
@@ -274,12 +262,26 @@ export function setupExtendedGlobals(globals, types) {
 							["_self", ANY],
 						]
 					: name === "bytes.Buffer"
-						? [["_buf", BYTE_SLICE_T]]
+						? [
+								["_buf", BYTE_SLICE_T],
+								["_lastOp", INT],
+								["_lastRuneLen", INT],
+							]
 						: [],
 			),
 			methods: new Map([..._builderBase, ...extra]),
 		},
 	});
+	const ioPkg = globals.lookup("io");
+	const IO_READER = ioPkg?.members?.Reader ?? {
+		kind: "interface",
+		name: "io.Reader",
+	};
+	const IO_WRITER = ioPkg?.members?.Writer ?? {
+		kind: "interface",
+		name: "io.Writer",
+	};
+
 	types.set(
 		"strings.Builder",
 		_makeBuilderType("strings.Builder", [
@@ -292,6 +294,34 @@ export function setupExtendedGlobals(globals, types) {
 			["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] }],
+			["ReadRune", { kind: "func", params: [], returns: [INT32, INT, ERROR] }],
+			["UnreadRune", { kind: "func", params: [], returns: [ERROR] }],
+			["ReadByte", { kind: "func", params: [], returns: [UINT8, ERROR] }],
+			["UnreadByte", { kind: "func", params: [], returns: [ERROR] }],
+			[
+				"ReadBytes",
+				{ kind: "func", params: [UINT8], returns: [BYTE_SLICE_T, ERROR] },
+			],
+			[
+				"ReadString",
+				{ kind: "func", params: [UINT8], returns: [STRING, ERROR] },
+			],
+			[
+				"ReadFrom",
+				{ kind: "func", params: [IO_READER], returns: [INT64, ERROR] },
+			],
+			[
+				"WriteTo",
+				{ kind: "func", params: [IO_WRITER], returns: [INT64, ERROR] },
+			],
+			["Next", { kind: "func", params: [INT], returns: [BYTE_SLICE_T] }],
+			["Truncate", { kind: "func", params: [INT], returns: [VOID] }],
+			["Available", { kind: "func", params: [], returns: [INT] }],
+			[
+				"AvailableBuffer",
+				{ kind: "func", params: [], returns: [BYTE_SLICE_T] },
+			],
+			["Peek", { kind: "func", params: [INT], returns: [BYTE_SLICE_T, ERROR] }],
 		]),
 	);
 	types.set("strings.Replacer", {
@@ -302,6 +332,14 @@ export function setupExtendedGlobals(globals, types) {
 			fields: new Map([["_pairs", STR_SLICE_T]]),
 			methods: new Map([
 				["Replace", { kind: "func", params: [STRING], returns: [STRING] }],
+				[
+					"WriteString",
+					{
+						kind: "func",
+						params: [IO_WRITER, STRING],
+						returns: [INT, ERROR],
+					},
+				],
 			]),
 		},
 	});
@@ -313,12 +351,37 @@ export function setupExtendedGlobals(globals, types) {
 			fields: new Map([
 				["_src", srcType],
 				["_pos", INT],
+				["_prev", INT],
 			]),
 			methods: new Map([
 				[
 					"Read",
 					{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
 				],
+				[
+					"ReadAt",
+					{
+						kind: "func",
+						params: [BYTE_SLICE_T, INT64],
+						returns: [INT, ERROR],
+					},
+				],
+				["ReadByte", { kind: "func", params: [], returns: [UINT8, ERROR] }],
+				["UnreadByte", { kind: "func", params: [], returns: [ERROR] }],
+				[
+					"ReadRune",
+					{ kind: "func", params: [], returns: [INT32, INT, ERROR] },
+				],
+				["UnreadRune", { kind: "func", params: [], returns: [ERROR] }],
+				[
+					"Seek",
+					{ kind: "func", params: [INT64, INT], returns: [INT64, ERROR] },
+				],
+				["Size", { kind: "func", params: [], returns: [INT64] }],
+				[
+					"WriteTo",
+					{ kind: "func", params: [IO_WRITER], returns: [INT64, ERROR] },
+				],
 				["Len", { kind: "func", params: [], returns: [INT] }],
 				["Reset", { kind: "func", params: [resetArgType], returns: [VOID] }],
 			]),
@@ -347,11 +410,6 @@ export function setupExtendedGlobals(globals, types) {
 			]),
 		},
 	});
-	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",
@@ -389,6 +447,7 @@ export function setupExtendedGlobals(globals, types) {
 			returns: [{ kind: "pointer", base: types.get("bytes.Reader") }],
 		};
 		bytesPkg.members.Reader = types.get("bytes.Reader");
+		bytesPkg.members.Buffer = types.get("bytes.Buffer");
 	}
 
 	globals.define("rand", {
@@ -484,6 +543,23 @@ export function setupExtendedGlobals(globals, types) {
 		members: globals.lookup("path").members,
 	});
 
+	const TIME_TIME = types.get("time.Time");
+	const TIME_DURATION = types.get("time.Duration");
+
+	const CONTEXT_T = {
+		kind: "named",
+		name: "context.Context",
+		underlying: {
+			kind: "interface",
+			methods: new Map([
+				["Deadline", { kind: "func", params: [], returns: [TIME_TIME, BOOL] }],
+				["Err", { kind: "func", params: [], returns: [ERROR] }],
+				["Value", { kind: "func", params: [ANY], returns: [ANY] }],
+			]),
+		},
+	};
+	types.set("context.Context", CONTEXT_T);
+
 	const TESTING_T = {
 		kind: "named",
 		name: "testing.T",
@@ -529,18 +605,237 @@ export function setupExtendedGlobals(globals, types) {
 			},
 		],
 		["Name", { kind: "func", params: [], returns: [STRING] }],
+		[
+			"Cleanup",
+			{
+				kind: "func",
+				params: [{ kind: "func", params: [], returns: [VOID] }],
+				returns: [VOID],
+			},
+		],
+		["Setenv", { kind: "func", params: [STRING, STRING], returns: [VOID] }],
+		["Deadline", { kind: "func", params: [], returns: [TIME_TIME, BOOL] }],
+		["Context", { kind: "func", params: [], returns: [CONTEXT_T] }],
+		["Parallel", { kind: "func", params: [], returns: [VOID] }],
+		["SkipNow", { kind: "func", params: [], returns: [VOID] }],
+		["Attr", { kind: "func", params: [STRING, STRING], returns: [VOID] }],
+		["Output", { kind: "func", params: [], returns: [IO_WRITER] }],
+	]);
+
+	const TESTING_B = {
+		kind: "named",
+		name: "testing.B",
+		underlying: {
+			kind: "struct",
+			fields: new Map([["N", INT]]),
+			methods: new Map(),
+		},
+	};
+	const TESTING_B_PTR = { kind: "pointer", base: TESTING_B };
+
+	TESTING_B.underlying.methods = new Map([
+		[
+			"Cleanup",
+			{
+				kind: "func",
+				params: [{ kind: "func", params: [], returns: [VOID] }],
+				returns: [VOID],
+			},
+		],
+		["Error", { kind: "func", params: [ANY], returns: [VOID], variadic: true }],
+		[
+			"Errorf",
+			{ kind: "func", params: [STRING, ANY], returns: [VOID], variadic: true },
+		],
+		["Fatal", { kind: "func", params: [ANY], returns: [VOID], variadic: true }],
+		[
+			"Fatalf",
+			{ kind: "func", params: [STRING, ANY], returns: [VOID], variadic: true },
+		],
+		["Fail", { kind: "func", params: [], returns: [VOID] }],
+		["Failed", { kind: "func", params: [], returns: [BOOL] }],
+		["FailNow", { kind: "func", params: [], returns: [VOID] }],
+		["Log", { kind: "func", params: [ANY], returns: [VOID], variadic: true }],
+		[
+			"Logf",
+			{ kind: "func", params: [STRING, ANY], returns: [VOID], variadic: true },
+		],
+		["Skip", { kind: "func", params: [ANY], returns: [VOID], variadic: true }],
+		[
+			"Skipf",
+			{ kind: "func", params: [STRING, ANY], returns: [VOID], variadic: true },
+		],
+		["Skipped", { kind: "func", params: [], returns: [BOOL] }],
+		["SkipNow", { kind: "func", params: [], returns: [VOID] }],
+		["Helper", { kind: "func", params: [], returns: [VOID] }],
+		["Name", { kind: "func", params: [], returns: [STRING] }],
+		["Attr", { kind: "func", params: [STRING, STRING], returns: [VOID] }],
+		["Context", { kind: "func", params: [], returns: [CONTEXT_T] }],
+		["Elapsed", { kind: "func", params: [], returns: [TIME_DURATION] }],
+		["Loop", { kind: "func", params: [], returns: [BOOL] }],
+		["Output", { kind: "func", params: [], returns: [IO_WRITER] }],
+		["ReportAllocs", { kind: "func", params: [], returns: [VOID] }],
+		[
+			"ReportMetric",
+			{ kind: "func", params: [FLOAT64, STRING], returns: [VOID] },
+		],
+		["ResetTimer", { kind: "func", params: [], returns: [VOID] }],
+		[
+			"Run",
+			{
+				kind: "func",
+				params: [
+					STRING,
+					{ kind: "func", params: [TESTING_B_PTR], returns: [VOID] },
+				],
+				returns: [BOOL],
+			},
+		],
+		["SetBytes", { kind: "func", params: [INT64], returns: [VOID] }],
+		["Setenv", { kind: "func", params: [STRING, STRING], returns: [VOID] }],
+		["StartTimer", { kind: "func", params: [], returns: [VOID] }],
+		["StopTimer", { kind: "func", params: [], returns: [VOID] }],
 	]);
 
+	const TESTING_M = {
+		kind: "named",
+		name: "testing.M",
+		underlying: {
+			kind: "struct",
+			fields: new Map(),
+			methods: new Map([["Run", { kind: "func", params: [], returns: [INT] }]]),
+		},
+	};
+
+	const TESTING_TB = {
+		kind: "named",
+		name: "testing.TB",
+		underlying: {
+			kind: "interface",
+			methods: new Map([
+				["Attr", { kind: "func", params: [STRING, STRING], returns: [VOID] }],
+				[
+					"Cleanup",
+					{
+						kind: "func",
+						params: [{ kind: "func", params: [], returns: [VOID] }],
+						returns: [VOID],
+					},
+				],
+				["Context", { kind: "func", params: [], returns: [CONTEXT_T] }],
+				[
+					"Error",
+					{ kind: "func", params: [ANY], returns: [VOID], variadic: true },
+				],
+				[
+					"Errorf",
+					{
+						kind: "func",
+						params: [STRING, ANY],
+						returns: [VOID],
+						variadic: true,
+					},
+				],
+				["Fail", { kind: "func", params: [], returns: [VOID] }],
+				["Failed", { kind: "func", params: [], returns: [BOOL] }],
+				["FailNow", { kind: "func", params: [], returns: [VOID] }],
+				[
+					"Fatal",
+					{ kind: "func", params: [ANY], returns: [VOID], variadic: true },
+				],
+				[
+					"Fatalf",
+					{
+						kind: "func",
+						params: [STRING, ANY],
+						returns: [VOID],
+						variadic: true,
+					},
+				],
+				["Helper", { kind: "func", params: [], returns: [VOID] }],
+				[
+					"Log",
+					{ kind: "func", params: [ANY], returns: [VOID], variadic: true },
+				],
+				[
+					"Logf",
+					{
+						kind: "func",
+						params: [STRING, ANY],
+						returns: [VOID],
+						variadic: true,
+					},
+				],
+				["Name", { kind: "func", params: [], returns: [STRING] }],
+				["Output", { kind: "func", params: [], returns: [IO_WRITER] }],
+				["Setenv", { kind: "func", params: [STRING, STRING], returns: [VOID] }],
+				[
+					"Skip",
+					{ kind: "func", params: [ANY], returns: [VOID], variadic: true },
+				],
+				[
+					"Skipf",
+					{
+						kind: "func",
+						params: [STRING, ANY],
+						returns: [VOID],
+						variadic: true,
+					},
+				],
+				["SkipNow", { kind: "func", params: [], returns: [VOID] }],
+				["Skipped", { kind: "func", params: [], returns: [BOOL] }],
+			]),
+		},
+	};
+
+	const BENCHMARK_RESULT_T = {
+		kind: "named",
+		name: "testing.BenchmarkResult",
+		underlying: {
+			kind: "struct",
+			fields: new Map([
+				["N", INT],
+				["T", TIME_DURATION],
+				["Bytes", INT64],
+				["MemAllocs", UINT64],
+				["MemBytes", UINT64],
+				["Extra", { kind: "map", key: STRING, value: FLOAT64 }],
+			]),
+			methods: new Map([
+				["AllocedBytesPerOp", { kind: "func", params: [], returns: [INT64] }],
+				["AllocsPerOp", { kind: "func", params: [], returns: [INT64] }],
+				["MemString", { kind: "func", params: [], returns: [STRING] }],
+				["NsPerOp", { kind: "func", params: [], returns: [INT64] }],
+				["String", { kind: "func", params: [], returns: [STRING] }],
+			]),
+		},
+	};
+
 	globals.define("testing", {
 		kind: "namespace",
 		name: "testing",
 		members: {
 			T: TESTING_T,
+			B: TESTING_B,
+			M: TESTING_M,
+			TB: TESTING_TB,
+			BenchmarkResult: BENCHMARK_RESULT_T,
+			Benchmark: {
+				kind: "func",
+				params: [{ kind: "func", params: [TESTING_B_PTR], returns: [VOID] }],
+				returns: [BENCHMARK_RESULT_T],
+			},
+			Init: { kind: "func", params: [], returns: [VOID] },
 			Short: { kind: "func", params: [], returns: [BOOL] },
+			Testing: { kind: "func", params: [], returns: [BOOL] },
 			Verbose: { kind: "func", params: [], returns: [BOOL] },
 		},
 	});
 	types.set("testing.T", TESTING_T);
+	types.set("testing.B", TESTING_B);
+	types.set("testing.M", TESTING_M);
+	types.set("testing.TB", TESTING_TB);
+	types.set("testing.BenchmarkResult", BENCHMARK_RESULT_T);
 
 	// ── sync ──────────────────────────────────────────────────────
 	const MUTEX_T = {
@@ -553,6 +848,14 @@ export function setupExtendedGlobals(globals, types) {
 			["TryLock", { kind: "func", params: [], returns: [BOOL] }],
 		]),
 	};
+	const LOCKER_T = {
+		kind: "interface",
+		name: "sync.Locker",
+		methods: new Map([
+			["Lock", { kind: "func", params: [], returns: [VOID] }],
+			["Unlock", { kind: "func", params: [], returns: [VOID] }],
+		]),
+	};
 	const RWMUTEX_T = {
 		kind: "named",
 		name: "sync.RWMutex",
@@ -562,6 +865,7 @@ export function setupExtendedGlobals(globals, types) {
 			["Unlock", { kind: "func", params: [], returns: [VOID] }],
 			["RLock", { kind: "func", params: [], returns: [VOID] }],
 			["RUnlock", { kind: "func", params: [], returns: [VOID] }],
+			["RLocker", { kind: "func", params: [], returns: [LOCKER_T] }],
 			["TryLock", { kind: "func", params: [], returns: [BOOL] }],
 			["TryRLock", { kind: "func", params: [], returns: [BOOL] }],
 		]),
@@ -591,14 +895,6 @@ export function setupExtendedGlobals(globals, types) {
 			["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",

package/src/typechecker/{stdlib.js → stdlib/index.js}

@@ -7,11 +7,11 @@
 //   stdlib/extended.js — gom, maps, regexp, rand, utf8, path, builder types,
 //                        built-in functions
 
-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";
+import { setupCoreGlobals } from "./core.js";
+import { setupExtendedGlobals } from "./extended.js";
+import { setupSharedGlobals } from "./shared.js";
+import { setupSimdGlobals } from "./simd.js";
+import { setupWebGlobals } from "./web.js";
 
 export function setupGlobals(globals, types) {
 	setupCoreGlobals(globals, types);

package/src/typechecker/stdlib/simd.js

@@ -5,7 +5,7 @@
 // - 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";
+import { BOOL, FLOAT32, INT } from "../types.js";
 
 export function setupSimdGlobals(globals, types) {
 	const f32x4Type = {
@@ -19,25 +19,69 @@ export function setupSimdGlobals(globals, types) {
 		},
 	};
 
+	const mask32x4Type = {
+		kind: "named",
+		name: "simd.Mask32x4",
+		underlying: {
+			kind: "simd",
+			simd: "Mask32x4",
+			elem: BOOL,
+			lanes: 4,
+		},
+	};
+
+	const fn = (params, returns) => ({ kind: "func", params, returns });
+	const unary = fn([], [f32x4Type]);
+	const binary = fn([f32x4Type], [f32x4Type]);
+	const compare = fn([f32x4Type], [mask32x4Type]);
+
 	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] }],
+		["Add", binary],
+		["Sub", binary],
+		["Mul", binary],
+		["Div", binary],
+		["Min", binary],
+		["Max", binary],
+		["MulAdd", fn([f32x4Type, f32x4Type], [f32x4Type])],
+		["Neg", unary],
+		["Abs", unary],
+		["Sqrt", unary],
+		["Floor", unary],
+		["Ceil", unary],
+		["Trunc", unary],
+		["RoundToEven", unary],
+		["Dot3", fn([f32x4Type], [FLOAT32])],
+		["Dot4", fn([f32x4Type], [FLOAT32])],
+		["Sum", fn([], [FLOAT32])],
+		["Lane", fn([INT], [FLOAT32])],
+		["WithLane", fn([INT, FLOAT32], [f32x4Type])],
+		["Splat", fn([FLOAT32], [f32x4Type])],
+		["Swizzle", fn([INT, INT, INT, INT], [f32x4Type])],
+		["Equal", compare],
+		["NotEqual", compare],
+		["Less", compare],
+		["LessEqual", compare],
+		["Greater", compare],
+		["GreaterEqual", compare],
+	]);
+
+	const maskBinary = fn([mask32x4Type], [mask32x4Type]);
+	mask32x4Type.underlying.methods = new Map([
+		["And", maskBinary],
+		["Or", maskBinary],
+		["Xor", maskBinary],
+		["AndNot", maskBinary],
+		["Not", fn([], [mask32x4Type])],
+		["Any", fn([], [BOOL])],
+		["All", fn([], [BOOL])],
+		["Bits", fn([], [INT])],
+		["Lane", fn([INT], [BOOL])],
 	]);
 
 	types.set("simd.F32x4", f32x4Type);
 	types.set("F32x4", f32x4Type);
+	types.set("simd.Mask32x4", mask32x4Type);
+	types.set("Mask32x4", mask32x4Type);
 
 	const sharedFloat32 = types.get("shared.Float32") ?? {
 		kind: "named",
@@ -47,6 +91,9 @@ export function setupSimdGlobals(globals, types) {
 
 	const members = {
 		F32x4: f32x4Type,
+		Mask32x4: mask32x4Type,
+		Select: fn([mask32x4Type, f32x4Type, f32x4Type], [f32x4Type]),
+		Shuffle: fn([f32x4Type, f32x4Type, INT, INT, INT, INT], [f32x4Type]),
 		NewF32x4: {
 			kind: "func",
 			params: [FLOAT32, FLOAT32, FLOAT32, FLOAT32],
@@ -62,6 +109,9 @@ export function setupSimdGlobals(globals, types) {
 			params: [sharedFloat32, INT],
 			returns: [f32x4Type],
 		},
+		LoadF32x4Slice: fn([{ kind: "slice", elem: FLOAT32 }, INT], [f32x4Type]),
+		StoreF32x4Slice: fn([{ kind: "slice", elem: FLOAT32 }, INT, f32x4Type], []),
+		Pad4: fn([INT], [INT]),
 		StoreF32x4: {
 			kind: "func",
 			params: [sharedFloat32, INT, f32x4Type],

package/src/typechecker/termination.js

@@ -19,7 +19,7 @@ export const terminationMethods = {
 			case "ReturnStmt":
 				return true;
 			case "BranchStmt":
-				return false;
+				return stmt.keyword === "goto";
 			case "ExprStmt":
 				return this._isPanicCall(stmt.expr);
 			case "LabeledStmt":