gofront 1.7.0 → 1.9.0

package/src/typechecker/stdlib/index.js

@@ -0,0 +1,38 @@
+// stdlib.js — built-in namespace and browser-global registration for the GoFront type
+// checker. Called once from TypeChecker._setupGlobals() during construction.
+//
+// Registers browser globals and built-in functions, then delegates to the
+// shared, simd and web sub-modules.
+
+import { ANY, BROWSER_GLOBALS } from "../types.js";
+import { setupSharedGlobals } from "./shared.js";
+import { setupSimdGlobals } from "./simd.js";
+import { setupWebGlobals } from "./web.js";
+
+export function setupGlobals(globals, types) {
+	for (const g of BROWSER_GLOBALS) globals.define(g, ANY);
+	for (const name of [
+		"append",
+		"len",
+		"cap",
+		"make",
+		"delete",
+		"print",
+		"println",
+		"panic",
+		"recover",
+		"new",
+		"copy",
+		"error",
+		"min",
+		"max",
+		"clear",
+		"complex",
+		"real",
+		"imag",
+	])
+		globals.define(name, { kind: "builtin", name });
+	setupSharedGlobals(globals, types);
+	setupSimdGlobals(globals, types);
+	setupWebGlobals(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":
@@ -64,15 +64,24 @@ export const terminationMethods = {
 
 	_isTerminatingSwitch(stmt) {
 		let hasDefault = false;
-		for (const c of stmt.cases ?? []) {
+		const cases = stmt.cases ?? [];
+		for (let i = 0; i < cases.length; i++) {
+			const c = cases[i];
 			if (!c.list) hasDefault = true;
 			if (!c.stmts?.length) return false;
 			const last = c.stmts[c.stmts.length - 1];
+			// `fallthrough` hands control to the next clause, which is checked
+			// on its own; the final clause has none to fall into.
+			if (this._isFallthrough(last) && i < cases.length - 1) continue;
 			if (!this._isTerminating(last)) return false;
 		}
 		return hasDefault;
 	},
 
+	_isFallthrough(stmt) {
+		return stmt?.kind === "BranchStmt" && stmt.keyword === "fallthrough";
+	},
+
 	_isTerminatingTypeSwitch(stmt) {
 		let hasDefault = false;
 		for (const c of stmt.cases ?? []) {