gofront 1.8.0 → 1.9.1

package/src/typechecker/statements.js

@@ -15,19 +15,28 @@ const CHECK_STMT_DELEGATE = {
 	BranchStmt: "_checkBranchStmt",
 };
 
+import { exprText, operandKind } from "./operand-text.js";
 import {
 	ANY,
 	BOOL,
 	defaultType,
+	is64BitInt,
 	isAny,
 	isBool,
+	isNil,
+	isString,
+	isUntyped,
 	isVoid,
 	iteratorYieldParams,
 	Scope,
+	typeStr,
 } from "./types.js";
 
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
 
+// Tag kinds with no nil value: `case nil` against them cannot compile.
+const NON_NILABLE_TAG_KINDS = new Set(["basic", "struct", "array"]);
+
 /** @type {ThisType<TypeChecker>} */
 export const statementCheckMethods = {
 	checkBlock(block, scope, returnType) {
@@ -67,18 +76,41 @@ export const statementCheckMethods = {
 
 	_checkDefineCommaOkAssert(stmt, rhs, scope) {
 		if (!stmt.rhs[0]?._commaOk) return false;
-		const lhsNames = stmt.lhs.map((e) => e.name ?? e);
-		if (lhsNames[0] !== "_") scope.defineLocal(lhsNames[0], rhs[0]);
-		if (lhsNames[1] !== "_") scope.defineLocal(lhsNames[1], BOOL);
+		this._declareDefineVars(stmt, [rhs[0], BOOL], scope);
+		if (stmt.lhs.every((e) => e._redecl || (e.name ?? e) === "_"))
+			this.err("no new variables on left side of :=", stmt.lhs[0]);
 		stmt._rhsTypes = [rhs[0], BOOL];
 		return true;
 	},
 
+	_assignOperand(stmt, i) {
+		if (stmt.rhs.length === stmt.lhs.length) return stmt.rhs[i];
+		return stmt.rhs.length === 1 ? stmt.rhs[0] : undefined;
+	},
+
+	_checkRedeclAssign(target, source, stmt, i) {
+		if (!target || !source || !this._needsAssignCheck(target, source)) return;
+		this._skipIfaceMark = true;
+		this.assertAssignable(
+			target,
+			source,
+			stmt.lhs[i],
+			"assignment",
+			this._assignOperand(stmt, i),
+		);
+		this._skipIfaceMark = false;
+	},
+
 	_declareDefineVars(stmt, rhsFlat, scope) {
 		for (let i = 0; i < stmt.lhs.length; i++) {
 			const name = stmt.lhs[i].name ?? stmt.lhs[i];
 			if (name === "_") continue;
-			if (scope.symbols.has(name)) stmt.lhs[i]._redecl = true;
+			if (scope.symbols.has(name)) {
+				stmt.lhs[i]._redecl = true;
+				// Redeclared variables keep their type; the value must be assignable.
+				this._checkRedeclAssign(scope.symbols.get(name), rhsFlat[i], stmt, i);
+				continue;
+			}
 			if (stmt.rhs.length === stmt.lhs.length)
 				this._checkConstDefault(
 					rhsFlat[i],
@@ -97,10 +129,10 @@ export const statementCheckMethods = {
 		)
 			return false;
 		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
-		const resolvedBase =
-			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
+		const resolvedBase = this._underlyingOrCore(mapBaseType, scope);
 		if (resolvedBase?.kind !== "map") return false;
 		const keyType = this.checkExpr(stmt.rhs[0].index, scope);
+		this.assertAssignable(resolvedBase.key, keyType, stmt.rhs[0].index);
 		this._markIfaceKey(resolvedBase, stmt.rhs[0].index, keyType);
 		stmt._commaOkMap = true;
 		stmt.rhs[0]._mapValueType = resolvedBase.value;
@@ -129,7 +161,8 @@ export const statementCheckMethods = {
 		if (this._checkDefineCommaOkAssert(stmt, rhs, scope)) return;
 		if (
 			stmt.rhs[0]?.kind !== "RangeExpr" &&
-			stmt.lhs.length !== rhsFlat.length
+			stmt.lhs.length !== rhsFlat.length &&
+			!rhsFlat.some((t) => t?._tainted)
 		) {
 			const vars =
 				stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
@@ -156,10 +189,10 @@ export const statementCheckMethods = {
 		)
 			return null;
 		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
-		const resolvedBase =
-			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
+		const resolvedBase = this._underlyingOrCore(mapBaseType, scope);
 		if (resolvedBase?.kind !== "map") return null;
 		const keyType = this.checkExpr(stmt.rhs[0].index, scope);
+		this.assertAssignable(resolvedBase.key, keyType, stmt.rhs[0].index);
 		this._markIfaceKey(resolvedBase, stmt.rhs[0].index, keyType);
 		stmt._commaOkMap = true;
 		stmt.rhs[0]._mapValueType = resolvedBase.value;
@@ -189,10 +222,37 @@ export const statementCheckMethods = {
 		return this.checkExpr(e, scope);
 	},
 
+	// A source-written `any` operand still goes through assertAssignable so a
+	// concrete target reports `need type assertion`; interop `any` stays exempt.
+	_needsAssignCheck(target, source) {
+		return !isAny(target) && (!isAny(source) || !!source._declared);
+	},
+
+	// A range assignment (`for _, s = range xs`) stores each key and element
+	// into an existing variable; one of interface type boxes the value as
+	// any other conversion does. The box is recorded on a holder, not on the
+	// target, which codegen also reads as an assignable expression.
+	_markRangeAssignBox(stmt, i, target, source) {
+		if (stmt.rhs[0]?.kind !== "RangeExpr") return;
+		this._markRangeTargetBox(stmt.lhs[i], target, source);
+	},
+
+	_markRangeTargetBox(node, target, source) {
+		if (!target || !source) return;
+		const holder = {};
+		this._markIfaceBox(
+			this.resolveType(target),
+			this.resolveType(source),
+			holder,
+		);
+		if (holder._ifaceBox) node._rangeBox = holder;
+	},
+
 	_checkAssignTypes(stmt, rhsFlat, lhsTypes) {
 		for (let i = 0; i < lhsTypes.length; i++) {
 			if (stmt.lhs[i]?.kind === "Ident" && stmt.lhs[i]?.name === "_") continue;
 			const r = rhsFlat[i] ?? ANY;
+			this._markRangeAssignBox(stmt, i, lhsTypes[i], r);
 			if (stmt.rhs.length === lhsTypes.length && lhsTypes[i] && r)
 				this._markIfaceBox(
 					this.resolveType(lhsTypes[i]),
@@ -209,9 +269,15 @@ export const statementCheckMethods = {
 				this._checkConstOverflow(lhsTypes[i], r, stmt.rhs[i], "assignment")
 			)
 				continue;
-			if (!isAny(lhsTypes[i]) && !isAny(r)) {
+			if (this._needsAssignCheck(lhsTypes[i], r)) {
 				this._skipIfaceMark = true;
-				this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
+				this.assertAssignable(
+					lhsTypes[i],
+					r,
+					stmt.lhs[i],
+					"assignment",
+					this._assignOperand(stmt, i),
+				);
 				this._skipIfaceMark = false;
 			}
 		}
@@ -231,7 +297,8 @@ export const statementCheckMethods = {
 			if (
 				!stmt.rhs[0]?._commaOk &&
 				stmt.rhs[0]?.kind !== "RangeExpr" &&
-				stmt.lhs.length !== rhsFlat.length
+				stmt.lhs.length !== rhsFlat.length &&
+				!rhsFlat.some((t) => t?._tainted)
 			) {
 				const vars =
 					stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
@@ -247,9 +314,34 @@ export const statementCheckMethods = {
 			}
 		}
 		const lhsTypes = stmt.lhs.map((e) => this._checkAssignLhsType(e, scope));
+		// A rejected range index is not checked again as an ordinary value.
+		if (this._checkRangeIndexAssign(stmt, lhsTypes))
+			rhsFlat = [ANY, ...rhsFlat.slice(1)];
 		this._checkAssignTypes(stmt, rhsFlat, lhsTypes);
 	},
 
+	// The index of a string, slice or array range is a typed `int`: Go assigns
+	// it only to `int` (or an interface), never to another integer type.
+	_checkRangeIndexAssign(stmt, lhsTypes) {
+		const range = stmt.rhs[0];
+		const lhs = stmt.lhs[0];
+		if (range?.kind !== "RangeExpr" || range._isIterator) return false;
+		if (!lhs || (lhs.kind === "Ident" && lhs.name === "_")) return false;
+		const target = lhsTypes[0];
+		if (!target || isAny(target) || typeStr(target) === "int") return false;
+		const coll = this.resolveType(range.expr._coreType ?? range.expr._type);
+		const cu =
+			coll?.kind === "named" ? this.resolveType(coll.underlying) : coll;
+		if (!isString(cu) && cu?.kind !== "slice" && cu?.kind !== "array")
+			return false;
+		const tu = this.resolveType(
+			target.kind === "named" ? target.underlying : target,
+		);
+		if (tu?.kind === "interface") return false;
+		this.err(`Cannot assign int to ${typeStr(target)}`, lhs);
+		return true;
+	},
+
 	_checkReturnStmt(stmt, scope, returnType) {
 		const types = stmt.values.map((v) => this.checkExpr(v, scope));
 		stmt._types = types;
@@ -274,14 +366,12 @@ export const statementCheckMethods = {
 					);
 					return;
 				}
-				for (let i = 0; i < expected.length; i++) {
-					this.assertAssignable(
-						expected[i],
-						forwarded[i],
-						stmt.values[0],
-						"return statement",
-					);
-				}
+				this._checkForwardedValues(
+					expected,
+					forwarded,
+					stmt.values[0],
+					"return statement",
+				);
 				return;
 			}
 			for (let i = 0; i < expected.length; i++) {
@@ -296,6 +386,35 @@ export const statementCheckMethods = {
 		}
 	},
 
+	// Checks each result of a forwarded multi-value call (`return f()`,
+	// `g(f())`) against its target.  Every element gets its own interface-box
+	// marks in `call._fwdIface` (null where nothing is boxed): tagging the
+	// shared call node would give every element the marks of the last one.
+	// Lowering splits such forwards into temps that carry these marks.
+	_checkForwardedValues(expected, forwarded, call, ctx) {
+		const skip = this._skipIfaceMark;
+		this._skipIfaceMark = true;
+		try {
+			for (let i = 0; i < expected.length; i++)
+				this.assertAssignable(expected[i], forwarded[i], call, ctx);
+		} finally {
+			this._skipIfaceMark = skip;
+		}
+		if (!skip) this._markForwardedElems(expected, forwarded, call);
+	},
+
+	// Records in `call._fwdIface` one interface-box mark holder per forwarded
+	// element (null where the element is not boxed), or clears it when no
+	// element enters an interface.
+	_markForwardedElems(expected, forwarded, call) {
+		const holders = expected.map((t, i) => {
+			const holder = {};
+			this._markIfaceBox(t, forwarded[i], holder);
+			return "_ifaceSrc" in holder ? holder : null;
+		});
+		call._fwdIface = holders.some(Boolean) ? holders : undefined;
+	},
+
 	_checkIfStmt(stmt, scope, returnType) {
 		const inner = new Scope(scope);
 		if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
@@ -321,6 +440,8 @@ export const statementCheckMethods = {
 				this.err("For condition must be bool", stmt);
 		} else {
 			const ct = this.checkExpr(stmt.cond.expr, inner);
+			const core = ct?.kind === "typeParam" ? this._coreType(ct, inner) : null;
+			if (core) stmt.cond.expr._coreType = core;
 			const info = iteratorYieldParams(ct);
 			if (info) {
 				stmt.cond._isIterator = true;
@@ -359,10 +480,18 @@ export const statementCheckMethods = {
 		const inner = new Scope(scope);
 		if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
 		if (stmt.tag) this.checkExpr(stmt.tag, inner);
+		const tagIs64 = stmt.tag && is64BitInt(stmt.tag._type);
 		this._switchDepth++;
 		for (const c of stmt.cases) {
 			const caseScope = new Scope(inner);
-			if (c.list) for (const e of c.list) this.checkExpr(e, caseScope);
+			if (c.list) {
+				for (const e of c.list) {
+					this.checkExpr(e, caseScope);
+					this._checkCaseValue(stmt.tag, e);
+					if (stmt.tag) this._tagFloat32Const(stmt.tag._type, e._type, e);
+					if (tagIs64 && e._type?.kind === "untyped") e._is64Bit = true;
+				}
+			}
 			for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
 			this._reportUnused(caseScope, stmt);
 		}
@@ -370,6 +499,92 @@ export const statementCheckMethods = {
 		this._reportUnused(inner, stmt);
 	},
 
+	// `case e:` compares `tag == e`, so `e` must convert to the tag's type
+	// (or the other way round for typed values).
+	_checkCaseValue(tag, e) {
+		const caseType = this.resolveType(e._type);
+		if (!tag) {
+			this._checkTaglessCase(e, caseType);
+			return;
+		}
+		let tagType = this.resolveType(tag._type);
+		// `switch "foo" {` compares as the constant's default type.
+		if (isUntyped(tagType) && !isNil(tagType)) tagType = defaultType(tagType);
+		if (this._caseValueUnchecked(tagType, caseType)) return;
+		if (isNil(caseType)) {
+			this.err(`cannot convert nil to type ${typeStr(tagType)}`, e);
+			return;
+		}
+		if (isUntyped(caseType)) {
+			if (this._isUntypedAssignable(tagType, caseType)) return;
+			this.err(
+				`cannot convert ${exprText(e)} (${operandKind(e, caseType.base, true)}) to type ${typeStr(tagType)}`,
+				e,
+			);
+			return;
+		}
+		if (
+			this._assignableQuietly(tagType, caseType) ||
+			this._assignableQuietly(caseType, tagType)
+		)
+			return;
+		this.err(
+			`invalid case ${exprText(e)} in switch on ${exprText(tag)} (mismatched types ${typeStr(caseType)} and ${typeStr(tagType)})`,
+			e,
+		);
+	},
+
+	// A tagless `switch` is `switch true`, so every case must be boolean.
+	_checkTaglessCase(e, caseType) {
+		if (!caseType || caseType._tainted || caseType.kind === "typeParam") return;
+		if (isNil(caseType)) {
+			this.err(`cannot convert nil to type bool`, e);
+			return;
+		}
+		if (isAny(caseType) || isBool(caseType)) return;
+		if (isUntyped(caseType) && caseType.base === "bool") return;
+		const under = this.resolveType(caseType.underlying ?? caseType);
+		if (isBool(under)) return;
+		this.err(
+			`invalid case ${exprText(e)} in switch (mismatched types ${typeStr(caseType)} and bool)`,
+			e,
+		);
+	},
+
+	// Operands whose comparison the checker cannot (or need not) judge: unknown
+	// or recovered types, `any`/interface tags, nil cases, type parameters.
+	_caseValueUnchecked(tagType, caseType) {
+		if (!tagType || !caseType || tagType._tainted || caseType._tainted)
+			return true;
+		if (isAny(tagType) || isAny(caseType)) return true;
+		if (isUntyped(tagType) || tagType.kind === "typeParam") return true;
+		if (isNil(caseType)) return this._nilCaseOk(tagType);
+		return (
+			this.resolveType(tagType.underlying ?? tagType)?.kind === "interface"
+		);
+	},
+
+	// `case nil` needs a tag with a nil value (pointer, slice, map, func,
+	// chan, interface); a basic, struct or array tag makes the caller report
+	// `cannot convert nil`.
+	_nilCaseOk(tagType) {
+		const kind = this._deepUnderlying(tagType)?.kind;
+		return !NON_NILABLE_TAG_KINDS.has(kind);
+	},
+
+	// Whether assertAssignable(target, source) reports nothing.
+	_assignableQuietly(target, source) {
+		const saved = this.errors;
+		const savedSkip = this._skipIfaceMark;
+		this.errors = [];
+		this._skipIfaceMark = true;
+		this.assertAssignable(target, source, null);
+		const ok = this.errors.length === 0;
+		this.errors = saved;
+		this._skipIfaceMark = savedSkip;
+		return ok;
+	},
+
 	// A case naming an interface (literal or declared) records the resolved
 	// type so backends test its method set.
 	_markInterfaceCaseType(t, scope) {
@@ -383,6 +598,23 @@ export const statementCheckMethods = {
 		if (u?.kind === "interface") t._type = resolved;
 	},
 
+	// Records the resolved type of a composite type node used as an assertion
+	// or type-switch target (`[]int`, `map[string]any`, `*int`, `iter.Seq[int]`)
+	// so the backend can match it against the dynamic type of an interface value.
+	_markDynamicType(node, resolved) {
+		const kind = node?.kind;
+		if (
+			kind === "SliceType" ||
+			kind === "ArrayType" ||
+			kind === "MapType" ||
+			kind === "PointerType" ||
+			kind === "FuncType" ||
+			kind === "StructType" ||
+			kind === "GenericTypeName"
+		)
+			node._assertType = resolved;
+	},
+
 	_checkTypeSwitchStmt(stmt, scope, returnType) {
 		const inner = new Scope(scope);
 		this.checkExpr(stmt.expr, inner);
@@ -396,9 +628,12 @@ export const statementCheckMethods = {
 				const base = t?.kind === "PointerType" ? t.base : t;
 				if (base?.kind === "GenericTypeName") this.resolveTypeNode(t, inner);
 				this._markInterfaceCaseType(t, inner);
+				if (t && t.kind !== "TypeName" && t.kind !== "InterfaceType")
+					this._markDynamicType(t, this.resolveTypeNode(t, inner));
 			}
 			if (stmt.assign) {
-				// Bind the variable to the single case type, or any for multi/default.
+				// Bind the variable to the single case type, or the switch operand's type
+				// for multi-type and default clauses, as Go does.
 				// `case nil` binds the switch expression's own type, as in Go.
 				const only = c.types?.length === 1 ? c.types[0] : null;
 				const isNilCase = only?.kind === "TypeName" && only.name === "nil";
@@ -406,7 +641,7 @@ export const statementCheckMethods = {
 					? (stmt.expr._type ?? ANY)
 					: only
 						? this.resolveTypeNode(only, inner)
-						: ANY;
+						: (stmt.expr._type ?? ANY);
 				caseScope.defineLocal(stmt.assign, bindType);
 				// The capture variable is always considered used — it's the whole
 				// point of the switch-with-assign form. Each case body uses its own
@@ -453,9 +688,35 @@ export const statementCheckMethods = {
 		}
 	},
 
-	_checkRangeIterAssignVars(lhs, scope) {
-		for (const e of lhs) {
-			if (e.kind === "Ident" && e.name !== "_") this.checkExpr(e, scope);
+	// Each yielded value is stored into an existing variable; one of
+	// interface type boxes the value as any other conversion does.
+	_checkRangeIterAssignVars(lhs, scope, yieldParams = []) {
+		lhs.forEach((e, i) => {
+			if (e.kind === "Ident" && e.name === "_") return;
+			const target = this.checkExpr(e, scope);
+			this._markRangeTargetBox(e, target, yieldParams[i]);
+			this._checkRangeIterAssignable(e, target, yieldParams[i]);
+		});
+	},
+
+	// The yielded value is assigned to the target, so it must be assignable
+	// to it (`for s = range seq` with `s string` and `seq` yielding `int`).
+	// The lenient `float64 = int` pair of plain assignments is reported here:
+	// the iterator loop stores the yielded value without converting it.
+	_checkRangeIterAssignable(node, target, source) {
+		if (!target || !source) return;
+		const t = this.resolveType(target);
+		const v = this.resolveType(source);
+		if (this._isNumericCoercible(t, v)) {
+			this.err(`Cannot assign ${typeStr(v)} to ${typeStr(t)}`, node);
+			return;
+		}
+		if (!this._needsAssignCheck(target, source)) return;
+		this._skipIfaceMark = true;
+		try {
+			this.assertAssignable(target, source, node, "assignment");
+		} finally {
+			this._skipIfaceMark = false;
 		}
 	},
 
@@ -481,7 +742,7 @@ export const statementCheckMethods = {
 
 		if (initStmt.kind === "DefineStmt")
 			this._bindRangeIterDefineVars(lhs, info, scope);
-		else this._checkRangeIterAssignVars(lhs, scope);
+		else this._checkRangeIterAssignVars(lhs, scope, info.yieldParams);
 		return info;
 	},
 };

package/src/typechecker/stdlib/excluded.js

@@ -155,7 +155,7 @@ const TRIMMED_UNICODE_TABLES =
 const TRIMMED_UNICODE_CASE =
 	"removed in v1.8.0; case ranges are not supported, use ToUpper, ToLower or ToTitle";
 const TRIMMED_FSCAN =
-	"removed in v1.8.0; scanning from an io.Reader is not supported, use fmt.Sscan on the text";
+	"removed in v1.8.0; scanning from an io.Reader is not supported, parse the text with strings and strconv";
 
 // reason -> package path -> excluded member names
 const EXCLUDED_MEMBER_GROUPS = {
@@ -188,6 +188,14 @@ const EXCLUDED_MEMBER_GROUPS = {
 	[TRIMMED_FSCAN]: {
 		fmt: ["Fscan", "Fscanf", "Fscanln"],
 	},
+	"removed in v1.9.0; reflection-based binary encoding is not supported, use binary.LittleEndian or binary.BigEndian methods (Uint32, PutUint32, AppendUint32, ...)":
+		{
+			"encoding/binary": ["Read", "Write", "Size"],
+		},
+	"removed in v1.9.0; format-string scanning is not supported, use strings.Fields with strconv.Atoi, ParseFloat or ParseBool":
+		{
+			fmt: ["Sscan", "Sscanf", "Sscanln"],
+		},
 	"removed in v1.8.0; this function is not supported": {
 		math: ["Gamma", "Erf"],
 	},
@@ -252,7 +260,6 @@ const EXCLUDED_MEMBER_GROUPS = {
 			"File.Chdir",
 			"File.Chmod",
 			"File.Chown",
-			"File.Close",
 			"File.Fd",
 			"File.Name",
 			"File.ReadAt",
@@ -393,7 +400,6 @@ const EXCLUDED_MEMBER_GROUPS = {
 			"SEEK_CUR",
 			"SEEK_END",
 			"SEEK_SET",
-			"Setenv",
 			"Signal",
 			"Signal.Signal",
 			"Signal.String",
@@ -809,8 +815,6 @@ const EXCLUDED_MEMBER_GROUPS = {
 const REMOVED_PACKAGES = {
 	bufio: "removed in v1.8.0; use strings and bytes readers",
 	"net/url": "removed in v1.8.0; use the URL class from a js package",
-	context:
-		"removed in v1.8.0; use a cancel flag, or AbortController from a js package",
 	"encoding/csv":
 		"removed in v1.8.0; split lines and fields with strings.Split",
 	"container/heap":

package/src/typechecker/stdlib/index.js

@@ -1,21 +1,37 @@
 // stdlib.js — built-in namespace and browser-global registration for the GoFront type
 // checker. Called once from TypeChecker._setupGlobals() during construction.
 //
-// Delegates to two focused sub-modules:
-//   stdlib/core.js     — browser globals, fmt, strings, bytes, strconv, sort,
-//                        math, errors, time, unicode, os, slices, html, io
-//   stdlib/extended.js — gom, maps, regexp, rand, utf8, path, builder types,
-//                        built-in functions
+// Registers browser globals and built-in functions, then delegates to the
+// shared, simd and web sub-modules.
 
-import { setupCoreGlobals } from "./core.js";
-import { setupExtendedGlobals } from "./extended.js";
+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) {
-	setupCoreGlobals(globals, types);
-	setupExtendedGlobals(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/termination.js

@@ -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 ?? []) {