cluaupp 1.5.2 → 2.0.0-beta.1

package/src/compiler/checker/statements.ts

@@ -0,0 +1,802 @@
+/** Statement checking. */
+
+import type { Expr, IterKind, MatchArm, Pattern, Stmt } from "../ast.js";
+import { isDynamic, isNumeric, isStringLike, nonNull, prune, T, typeToString, type Type } from "../types.js";
+import { foldConstant, widenLiteral, type Checker } from "./checker.js";
+import { checkCondition, checkExpr, exprPathKey, rootSymbol } from "./exprs.js";
+import { alwaysExits, applyNarrowings, conditionNarrowings, containsBreak } from "./flow.js";
+import { checkAssignTarget } from "./members.js";
+import type { Sym } from "./symbols.js";
+import { assignable } from "./typeops.js";
+import { mayYield } from "./yields.js";
+
+export function checkStatement(c: Checker, stmt: Stmt): void {
+	switch (stmt.kind) {
+		case "Var":
+			checkVar(c, stmt);
+			return;
+		case "Assign":
+			checkAssign(c, stmt);
+			return;
+		case "Expr":
+			checkExprStatement(c, stmt);
+			return;
+		case "If":
+			checkIf(c, stmt);
+			return;
+		case "While": {
+			const cond = checkCondition(c, stmt.cond);
+			void cond;
+			c.loopDepth++;
+			const scope = c.pushScope("loop");
+			applyNarrowings(scope, conditionNarrowings(c, stmt.cond, true));
+			for (const s of stmt.body) {
+				checkStatement(c, s);
+			}
+			c.popScope();
+			c.loopDepth--;
+			checkInfiniteLoop(c, stmt, stmt.cond.kind === "Bool" && stmt.cond.value, stmt.body);
+			return;
+		}
+		case "For": {
+			c.pushScope("loop");
+			if (stmt.init) {
+				checkStatement(c, stmt.init);
+			}
+			if (stmt.cond) {
+				checkCondition(c, stmt.cond);
+			}
+			c.loopDepth++;
+			c.pushScope("block");
+			for (const s of stmt.body) {
+				checkStatement(c, s);
+			}
+			c.popScope();
+			c.loopDepth--;
+			if (stmt.step) {
+				checkStatement(c, stmt.step);
+			}
+			c.popScope();
+			checkInfiniteLoop(c, stmt, stmt.cond === null || (stmt.cond.kind === "Bool" && stmt.cond.value), stmt.body);
+			return;
+		}
+		case "ForIn":
+			checkForIn(c, stmt);
+			return;
+		case "Break":
+			if (c.loopDepth === 0 && c.switchDepth === 0) {
+				c.error("CL4003", stmt.span, "break outside of a loop or switch");
+			}
+			return;
+		case "Continue":
+			if (c.loopDepth === 0) {
+				c.error("CL4003", stmt.span, "continue outside of a loop");
+			}
+			return;
+		case "Return":
+			checkReturn(c, stmt);
+			return;
+		case "Switch":
+			checkSwitch(c, stmt);
+			return;
+		case "Match":
+			checkMatch(c, stmt);
+			return;
+		case "Try": {
+			c.pushScope("block");
+			for (const s of stmt.body) {
+				checkStatement(c, s);
+			}
+			c.popScope();
+			c.pushScope("block");
+			if (stmt.catchName) {
+				const sym = c.declare(stmt.catchName.name, "var", T.string, stmt.catchName.span);
+				sym.used = true;
+				stmt.catchName.sym = sym;
+			}
+			for (const s of stmt.handler) {
+				checkStatement(c, s);
+			}
+			c.popScope();
+			return;
+		}
+		case "Output": {
+			const t = checkExpr(c, stmt.value);
+			if (prune(t).k === "void") {
+				c.error("CL3013", stmt.value.span, "this expression has no value to print");
+			}
+			return;
+		}
+		case "Connect":
+			checkConnect(c, stmt);
+			return;
+		case "Signal": {
+			if (c.scope === c.fileScope && stmt.name.sym) {
+				return; // declared in the declare pass
+			}
+			const params = stmt.params.map((p) => c.resolveType(p));
+			const sym = c.declare(stmt.name.name, "signal", { k: "clSignal", params: params.length ? params : null }, stmt.name.span);
+			sym.signalParams = params.length ? params : null;
+			sym.used = true;
+			stmt.name.sym = sym;
+			return;
+		}
+		case "Using": {
+			const mod = c.scope.lookup(stmt.module);
+			if (!mod || mod.kind !== "module") {
+				c.error("CL2001", stmt.span, `'${stmt.module}' is not a linked module`);
+				return;
+			}
+			mod.used = true;
+			const fake: Expr = {
+				kind: "Member",
+				object: { kind: "Name", name: stmt.module, typeArgs: null, span: stmt.span },
+				name: stmt.member,
+				nameSpan: stmt.memberSpan,
+				typeArgs: null,
+				span: stmt.span,
+			};
+			const t = checkExpr(c, fake);
+			const sym = c.declare(stmt.member, "const", t, stmt.memberSpan);
+			sym.used = true;
+			stmt.target = fake;
+			stmt.sym = sym;
+			if (fake.res?.kind === "const") {
+				sym.constValue = fake.res.value;
+			}
+			return;
+		}
+		case "Block":
+			c.pushScope("block");
+			for (const s of stmt.body) {
+				checkStatement(c, s);
+			}
+			c.popScope();
+			return;
+		case "Decl": {
+			const decl = stmt.decl;
+			if (decl.kind === "Func" && c.fn) {
+				const sym = c.declare(decl.name, "func", c.signatureOf(decl, null), decl.nameSpan);
+				sym.decl = decl;
+				sym.used = true;
+				c.funcSyms.set(decl, sym);
+				checkNestedFunction(c, decl, sym);
+				return;
+			}
+			if (c.fn || c.scope !== c.fileScope) {
+				c.error("CL2030", stmt.span, `${decl.kind.toLowerCase()} declarations must be at the top level of the file`);
+			}
+			return;
+		}
+		default:
+			return;
+	}
+}
+
+function checkNestedFunction(c: Checker, decl: Extract<Stmt, { kind: "Decl" }>["decl"] & { kind: "Func" }, sym: Sym): void {
+	const outer = c.fn!;
+	const ctx = { ...outer, decl, declaredRet: decl.returnType ? c.resolveType(decl.returnType) : null, returns: [] as Type[], depth: outer.depth + 1, yields: false, sym };
+	c.fn = ctx;
+	c.pushScope("function");
+	c.declareParams(decl.params);
+	for (const s of decl.body || []) {
+		checkStatement(c, s);
+	}
+	c.finishFunction(ctx, decl.body || [], decl.nameSpan, decl.name);
+	c.popScope();
+	c.fn = outer;
+	if (ctx.yields) {
+		outer.yields = true;
+	}
+	const fnType = sym.type as Extract<Type, { k: "func" }>;
+	if (!decl.returnType && prune(fnType.ret).k === "infer") {
+		(prune(fnType.ret) as { resolved: Type | null }).resolved = ctx.returns.length ? ctx.returns.reduce((a, b) => (sameish(a, b) ? a : T.any)) : T.void;
+	}
+	(decl.fn ||= {}).mayYield = ctx.yields;
+}
+
+function sameish(a: Type, b: Type): boolean {
+	return typeToString(a) === typeToString(b);
+}
+
+// ---------- declarations ----------
+
+function checkVar(c: Checker, stmt: Extract<Stmt, { kind: "Var" }>): void {
+	const predeclared = stmt.predeclared === true;
+	let declared: Type | null = null;
+	if (stmt.declaredType) {
+		declared = c.resolveType(stmt.declaredType);
+	} else if (stmt.decltypeOf) {
+		declared = widenLiteral(checkExpr(c, stmt.decltypeOf));
+	} else if (stmt.declKind === "atomic") {
+		declared = T.int;
+	}
+	let initType: Type | null = null;
+	if (stmt.init) {
+		initType = checkExpr(c, stmt.init, declared ?? undefined, stmt.unpack);
+		if (prune(initType).k === "void") {
+			c.error("CL3013", stmt.init.span, "this expression has no value");
+			initType = T.unknown;
+		}
+		if (declared) {
+			c.expectAssignable(declared, initType, stmt.init.span, `cannot initialize '${stmt.names.map((n) => n.name).join(", ")}'`);
+		}
+		c.markCopy(stmt.init);
+	} else if (!declared || (prune(declared).k !== "option" && prune(declared).k !== "any")) {
+		const name = stmt.names[0].name;
+		c.error("CL3014", stmt.span, `'${name}' needs an initial value`, declared && prune(declared).k === "instance" ? [`write \`${typeToString(declared)}? ${name} = null;\` for an Instance that starts empty`] : ["CL++ variables are always initialized: `let x = …;`"]);
+	}
+	if (stmt.declKind === "constexpr" && stmt.init && foldConstant(stmt.init) === undefined) {
+		c.error("CL3015", stmt.init.span, "constexpr needs a value computable at compile time (literals and arithmetic on them)");
+	}
+	const mutable = stmt.declKind === "let mut" || stmt.declKind === "typed" || stmt.declKind === "auto" || stmt.declKind === "observable" || stmt.declKind === "decltype";
+	if (stmt.unpack) {
+		const src = prune(initType ?? T.unknown);
+		stmt.names.forEach((n, i) => {
+			let t: Type = T.any;
+			if (src.k === "list") {
+				t = src.elem;
+			} else if (src.k === "tuple") {
+				t = src.elems[i] ?? T.void;
+				if (i >= src.elems.length) {
+					c.error("CL3016", n.span, `the value only has ${src.elems.length} element(s)`);
+				}
+			} else if (!isDynamic(src)) {
+				c.error("CL3016", stmt.init?.span ?? stmt.span, `cannot destructure ${typeToString(src)}; expected a list`);
+			}
+			const sym = c.declare(n.name, "var", widenLiteral(t), n.span, mutable);
+			n.sym = sym;
+		});
+		return;
+	}
+	const n = stmt.names[0];
+	let type: Type = declared ?? widenLiteral(initType ?? T.unknown);
+	if (stmt.declaredType && stmt.declaredType.kind === "Literal") {
+		type = declared!;
+	}
+	if (predeclared && n.sym) {
+		const pre = n.sym as Sym;
+		if (prune(pre.type).k === "unknown") {
+			pre.type = type;
+		}
+		return;
+	}
+	const kind = stmt.declKind === "const" || stmt.declKind === "constexpr" ? "const" : "var";
+	const sym = c.declare(n.name, kind, type, n.span, mutable);
+	n.sym = sym;
+	if (kind === "const" && stmt.init) {
+		const v = foldConstant(stmt.init);
+		if (v !== undefined) {
+			sym.constValue = v;
+		}
+	}
+	if (stmt.declKind === "observable") {
+		sym.observable = true;
+		sym.handlers = [];
+	}
+	if (stmt.declKind === "atomic") {
+		sym.atomic = true;
+	}
+	if (initType && prune(initType).k !== "null" && prune(type).k === "option") {
+		// `Part? p = Part()` is known non-null until reassigned.
+		const key = `s${sym.id}`;
+		if (prune(initType).k !== "option") {
+			c.scope.narrowed.set(key, nonNull(type));
+		}
+	}
+}
+
+// ---------- assignment ----------
+
+function checkAssign(c: Checker, stmt: Extract<Stmt, { kind: "Assign" }>): void {
+	const target = checkAssignTarget(c, stmt.target, stmt.op !== "=");
+	const targetType = target.type;
+	let valueType = checkExpr(c, stmt.value, stmt.op === "=" ? targetType : undefined);
+	if (stmt.op === "=") {
+		c.expectAssignable(targetType, valueType, stmt.value.span, "cannot assign");
+		c.markCopy(stmt.value);
+	} else {
+		const op = stmt.op[0];
+		const tt = prune(targetType);
+		const vt = prune(valueType);
+		if (isNumeric(tt) && isNumeric(vt)) {
+			if (tt.k === "int" && (vt.k === "float" || (vt.k === "lit" && !Number.isInteger(vt.value)))) {
+				c.error("CL3012", stmt.value.span, `'${stmt.op}' would store a float in the int '${describeTarget(stmt.target)}'`, ["convert with int(...) or declare the variable as float"]);
+			}
+		} else if (tt.k === "datatype" || vt.k === "datatype") {
+			const result = c.api.operator(op, tt, vt);
+			if (!result) {
+				c.error("CL3017", stmt.span, `'${stmt.op}' is not defined for ${typeToString(tt)} and ${typeToString(vt)}`);
+			} else {
+				valueType = result;
+			}
+		} else if (!isDynamic(tt) && !isDynamic(vt)) {
+			if (stmt.op === "+=" && isStringLike(tt)) {
+				c.error("CL3017", stmt.span, "strings are joined with `.:` in CL++", [`write \`${describeTarget(stmt.target)} = ${describeTarget(stmt.target)} .: …;\``]);
+			} else {
+				c.error("CL3017", stmt.span, `'${stmt.op}' needs numbers, got ${typeToString(tt)} and ${typeToString(vt)}`);
+			}
+		}
+	}
+	const key = exprPathKey(stmt.target);
+	if (key) {
+		c.scope.invalidate(key);
+		const vt = prune(valueType);
+		if (stmt.op === "=" && prune(targetType).k === "option" && vt.k !== "option" && vt.k !== "null" && !isDynamic(vt)) {
+			c.scope.narrowed.set(key, nonNull(targetType));
+		}
+	}
+}
+
+function describeTarget(e: Expr): string {
+	switch (e.kind) {
+		case "Name":
+			return e.name;
+		case "Member":
+			return `${describeTarget(e.object)}.${e.name}`;
+		case "SelfField":
+			return `@${e.name}`;
+		case "Index":
+			return `${describeTarget(e.object)}[…]`;
+		default:
+			return "value";
+	}
+}
+
+function checkExprStatement(c: Checker, stmt: Extract<Stmt, { kind: "Expr" }>): void {
+	const e = stmt.expr;
+	checkExpr(c, e);
+	switch (e.kind) {
+		case "Call":
+		case "New":
+		case "Update":
+		case "Await":
+		case "Spawn":
+		case "Thread":
+		case "Join":
+		case "Parallel":
+		case "PCall":
+		case "Error":
+			return;
+		default:
+			c.warn("CL4004", e.span, "this expression has no effect", ["did you mean an assignment or a call?"]);
+	}
+}
+
+// ---------- control flow ----------
+
+function checkIf(c: Checker, stmt: Extract<Stmt, { kind: "If" }>): void {
+	if (stmt.letName) {
+		const t = checkExpr(c, stmt.cond);
+		const scope = c.pushScope("block");
+		const sym = c.declare(stmt.letName.name, "var", widenLiteral(nonNull(t)), stmt.letName.span);
+		sym.used = true;
+		stmt.letName.sym = sym;
+		void scope;
+		for (const s of stmt.then) {
+			checkStatement(c, s);
+		}
+		c.popScope();
+		if (stmt.else) {
+			c.pushScope("block");
+			for (const s of stmt.else) {
+				checkStatement(c, s);
+			}
+			c.popScope();
+		}
+		return;
+	}
+	checkCondition(c, stmt.cond);
+	const yes = conditionNarrowings(c, stmt.cond, true);
+	const no = conditionNarrowings(c, stmt.cond, false);
+	const thenScope = c.pushScope("block");
+	applyNarrowings(thenScope, yes);
+	for (const s of stmt.then) {
+		checkStatement(c, s);
+	}
+	c.popScope();
+	if (stmt.else) {
+		const elseScope = c.pushScope("block");
+		applyNarrowings(elseScope, no);
+		for (const s of stmt.else) {
+			checkStatement(c, s);
+		}
+		c.popScope();
+	}
+	const thenExits = alwaysExits(c, stmt.then);
+	const elseExits = stmt.else ? alwaysExits(c, stmt.else) : false;
+	if (thenExits && !elseExits) {
+		applyNarrowings(c.scope, no);
+	} else if (elseExits && !thenExits) {
+		applyNarrowings(c.scope, yes);
+	}
+}
+
+function iterationOf(c: Checker, t: Type, span: Expr["span"]): { kind: IterKind; elem: Type } {
+	const p = prune(t);
+	switch (p.k) {
+		case "int":
+		case "lit":
+			if (typeof (p as { value?: unknown }).value === "string") {
+				return { kind: "string", elem: T.string };
+			}
+			return { kind: "range", elem: T.int };
+		case "float":
+			c.error("CL3018", span, "for … in over a number needs an int count", ["convert with int(...)"]);
+			return { kind: "range", elem: T.int };
+		case "string":
+			return { kind: "string", elem: T.string };
+		case "list":
+			return { kind: "list", elem: p.elem };
+		case "tuple":
+			return { kind: "list", elem: p.elems.reduce((a, b) => (typeToString(a) === typeToString(b) ? a : T.any), p.elems[0] ?? T.any) };
+		case "dict":
+			return { kind: "dict", elem: p.key };
+		case "table":
+			return { kind: "dict", elem: T.string };
+		case "option":
+			c.strictError("CL3011", span, `${typeToString(p)} may be null; check it before iterating`);
+			return iterationOf(c, p.inner, span);
+		case "any":
+		case "unknown":
+		case "infer":
+			return { kind: "generic", elem: T.any };
+		case "instance":
+			c.error("CL3018", span, `cannot iterate over ${p.cls} itself`, ["iterate its children: `for (let child in x.GetChildren())`"]);
+			return { kind: "generic", elem: T.any };
+		default:
+			c.error("CL3018", span, `cannot iterate over ${typeToString(p)}`);
+			return { kind: "generic", elem: T.any };
+	}
+}
+
+function checkForIn(c: Checker, stmt: Extract<Stmt, { kind: "ForIn" }>): void {
+	const it = checkExpr(c, stmt.iterable);
+	const { kind, elem } = iterationOf(c, it, stmt.iterable.span);
+	stmt.iterKind = kind;
+	let varType = widenLiteral(elem);
+	if (stmt.declaredType) {
+		const declared = c.resolveType(stmt.declaredType);
+		const r = assignable(c, declared, elem);
+		const de = prune(declared);
+		const ee = prune(elem);
+		const downcast = de.k === "instance" && ee.k === "instance" && c.api.isA(de.cls, ee.cls);
+		if (r !== "ok" && !downcast) {
+			c.expectAssignable(declared, elem, stmt.iterable.span, `loop variable '${stmt.name.name}'`);
+		}
+		varType = declared;
+		if (downcast) {
+			stmt.downcast = true;
+		}
+	}
+	c.loopDepth++;
+	c.pushScope("loop");
+	const sym = c.declare(stmt.name.name, "var", varType, stmt.name.span, stmt.mutable);
+	sym.used = sym.used || stmt.name.name === "_";
+	stmt.name.sym = sym;
+	for (const s of stmt.body) {
+		checkStatement(c, s);
+	}
+	c.popScope();
+	c.loopDepth--;
+	if (!sym.used && !stmt.name.name.startsWith("_")) {
+		// reported by popScope as unused
+	}
+}
+
+function checkReturn(c: Checker, stmt: Extract<Stmt, { kind: "Return" }>): void {
+	const fn = c.fn;
+	if (!fn) {
+		if (c.input.kind === "module") {
+			c.error("CL4005", stmt.span, "return outside of a function");
+		} else if (stmt.value) {
+			c.error("CL4005", stmt.span, "a script cannot return a value");
+		}
+		if (stmt.value) {
+			checkExpr(c, stmt.value);
+		}
+		return;
+	}
+	const expected = fn.declaredRet;
+	if (!stmt.value) {
+		if (expected && !isDynamic(expected) && prune(expected).k !== "void" && prune(expected).k !== "option") {
+			c.error("CL4006", stmt.span, `'${fn.decl?.name ?? "function"}' must return ${typeToString(expected)}`);
+		}
+		fn.returns.push(T.void);
+		return;
+	}
+	const t = checkExpr(c, stmt.value, expected ?? undefined);
+	// Returning a local hands it over (it dies with the frame); only aliased places need a copy.
+	if (!(stmt.value.kind === "Name" && stmt.value.res?.kind === "local")) {
+		c.markCopy(stmt.value);
+	}
+	if (expected) {
+		if (prune(expected).k === "void" && prune(t).k !== "void") {
+			c.error("CL4007", stmt.value.span, `'${fn.decl?.name ?? "function"}' is declared -> void and cannot return a value`);
+		} else {
+			c.expectAssignable(expected, t, stmt.value.span, "cannot return this value");
+		}
+	}
+	fn.returns.push(t);
+}
+
+function checkSwitch(c: Checker, stmt: Extract<Stmt, { kind: "Switch" }>): void {
+	const subject = checkExpr(c, stmt.subject);
+	c.switchDepth++;
+	for (const k of stmt.cases) {
+		if (k.test) {
+			const t = checkExpr(c, k.test, subject);
+			if (assignable(c, widenLiteral(subject), t) === "no" && assignable(c, widenLiteral(t), subject) === "no") {
+				c.error("CL3019", k.test.span, `case ${typeToString(t)} can never match a ${typeToString(subject)}`);
+			}
+		}
+		c.pushScope("block");
+		for (const s of k.body) {
+			checkStatement(c, s);
+		}
+		c.popScope();
+	}
+	c.switchDepth--;
+}
+
+// ---------- match ----------
+
+function checkMatch(c: Checker, stmt: Extract<Stmt, { kind: "Match" }>): void {
+	const subjectType = checkExpr(c, stmt.subject);
+	const subject = prune(subjectType);
+	const covered = new Set<string>();
+	let wildcard = false;
+	for (const arm of stmt.arms) {
+		if (wildcard) {
+			c.warn("CL4008", arm.span, "this arm is unreachable: an earlier `_` arm matches everything");
+		}
+		c.pushScope("block");
+		const bound = checkPattern(c, arm.pattern, subject, covered);
+		if (arm.pattern.kind === "Wildcard" && !arm.guard) {
+			wildcard = true;
+		}
+		if (bound && arm.pattern.kind === "Case" && arm.pattern.binding) {
+			const sym = c.declare(arm.pattern.binding.name, "var", bound, arm.pattern.binding.span);
+			sym.used = true;
+			arm.pattern.binding.sym = sym;
+		}
+		if (arm.guard) {
+			checkCondition(c, arm.guard);
+			applyNarrowings(c.scope, conditionNarrowings(c, arm.guard, true));
+		}
+		for (const s of arm.body) {
+			checkStatement(c, s);
+		}
+		c.popScope();
+		if (arm.guard && arm.pattern.kind === "Case") {
+			covered.delete(arm.pattern.name);
+		}
+	}
+	const required = requiredCases(c, subject);
+	if (required && !wildcard) {
+		const missing = required.filter((r) => !covered.has(r));
+		if (missing.length) {
+			c.error("CL4009", stmt.span, `non-exhaustive match: missing ${missing.map((m) => `'${m}'`).join(", ")}`, ["add the missing arms or a `_ ~> …` arm"]);
+		} else {
+			stmt.exhaustive = true;
+		}
+	} else if (wildcard) {
+		stmt.exhaustive = true;
+	}
+}
+
+function requiredCases(c: Checker, subject: Type): string[] | null {
+	switch (subject.k) {
+		case "enum": {
+			const info = c.enums.get(subject.id);
+			return info ? info.cases.map((k) => k.name) : null;
+		}
+		case "option":
+			return ["Some", "None"];
+		case "result":
+			return ["Ok", "Err"];
+		case "bool":
+			return ["true", "false"];
+		default:
+			return null;
+	}
+}
+
+/** Resolve a pattern against the subject; returns the type bound by `Case(x)`. */
+function checkPattern(c: Checker, pattern: Pattern, subject: Type, covered: Set<string>): Type | null {
+	if (pattern.kind === "Wildcard") {
+		return null;
+	}
+	if (pattern.kind === "Value") {
+		const t = checkExpr(c, pattern.expr, subject);
+		if (pattern.expr.kind === "Bool") {
+			covered.add(String(pattern.expr.value));
+		}
+		if (pattern.expr.res?.kind === "enumCase" && subject.k === "enum") {
+			const info = c.enums.get(subject.id);
+			const name = info?.cases[pattern.expr.res.index]?.name;
+			if (name) {
+				covered.add(name);
+			}
+		}
+		if (assignable(c, widenLiteral(subject), t) === "no" && assignable(c, widenLiteral(t), subject) === "no" && !isDynamic(subject)) {
+			c.error("CL3019", pattern.span, `pattern ${typeToString(t)} can never match a ${typeToString(subject)}`);
+		}
+		return null;
+	}
+	const name = pattern.name;
+	switch (subject.k) {
+		case "enum": {
+			const info = c.enums.get(subject.id);
+			const index = info ? info.cases.findIndex((k) => k.name === name) : -1;
+			if (!info || index < 0) {
+				return valueFallback(c, pattern, subject);
+			}
+			const kase = info.cases[index];
+			pattern.res = { kind: "enumCase", enumName: info.id, index, hasPayload: Boolean(kase.payload), anyPayload: info.hasPayload };
+			covered.add(name);
+			if (pattern.binding && !kase.payload) {
+				c.error("CL3031", pattern.span, `${info.name}.${name} carries no value to bind`);
+			}
+			return kase.payload;
+		}
+		case "option":
+			if (name === "Some") {
+				covered.add("Some");
+				pattern.res = { kind: "builtin", name: "Some" };
+				return subject.inner;
+			}
+			if (name === "None") {
+				covered.add("None");
+				pattern.res = { kind: "builtin", name: "None" };
+				return null;
+			}
+			return valueFallback(c, pattern, subject);
+		case "result":
+			if (name === "Ok" || name === "Err") {
+				covered.add(name);
+				pattern.res = { kind: "builtin", name };
+				return name === "Ok" ? subject.ok : subject.err;
+			}
+			return valueFallback(c, pattern, subject);
+		case "rbxEnumItem": {
+			const items = c.api.enums[subject.enumName]?.items || [];
+			if (items.includes(name)) {
+				pattern.res = { kind: "rbxEnumItem", enumName: subject.enumName, item: name };
+				return null;
+			}
+			return valueFallback(c, pattern, subject);
+		}
+		default:
+			if (name === "Some" || name === "None") {
+				if (!isDynamic(subject)) {
+					c.error("CL3032", pattern.span, `${name} only matches an Option, but the subject is ${typeToString(subject)}`);
+				}
+				pattern.res = { kind: "builtin", name };
+				return pattern.binding ? T.any : null;
+			}
+			return valueFallback(c, pattern, subject);
+	}
+}
+
+/** `case` name that is not a variant: compare against a constant/variable with that name. */
+function valueFallback(c: Checker, pattern: Extract<Pattern, { kind: "Case" }>, subject: Type): Type | null {
+	if (pattern.binding) {
+		c.error("CL3033", pattern.span, `'${pattern.name}' is not a case of ${typeToString(subject)}`);
+		return T.unknown;
+	}
+	const expr: Expr = pattern.qualifier
+		? { kind: "Member", object: pattern.qualifier, name: pattern.name, nameSpan: pattern.span, typeArgs: null, span: pattern.span }
+		: { kind: "Name", name: pattern.name, typeArgs: null, span: pattern.span };
+	const t = checkExpr(c, expr, subject);
+	pattern.valueExpr = expr;
+	if (assignable(c, widenLiteral(subject), t) === "no" && !isDynamic(t) && !isDynamic(subject)) {
+		const info = subject.k === "enum" ? c.enums.get(subject.id) : null;
+		c.error("CL3033", pattern.span, `'${pattern.name}' is not a case of ${typeToString(subject)}`, info ? [`cases: ${info.cases.map((k) => k.name).join(", ")}`] : undefined);
+	}
+	return null;
+}
+
+// ---------- connections ----------
+
+function checkConnect(c: Checker, stmt: Extract<Stmt, { kind: "Connect" }>): void {
+	const signalType = prune(checkExpr(c, stmt.signal));
+	if (signalType.k === "clSignal") {
+		const sym = rootSymbol(stmt.signal);
+		const expected: Type = signalType.params ? T.func(signalType.params.map((p, i) => ({ name: `arg${i + 1}`, type: p, optional: false })), T.void) : T.func([], T.void);
+		const handlerType = prune(checkExpr(c, stmt.handler, signalType.params ? expected : undefined));
+		if (handlerType.k !== "func" && !isDynamic(handlerType)) {
+			c.error("CL3034", stmt.handler.span, "a signal connects to a function name or `func (…) { … }`");
+		}
+		if (sym) {
+			(sym.handlers ||= []).push(stmt.handler);
+			sym.used = true;
+		}
+		stmt.target = "cl";
+		return;
+	}
+	if (signalType.k === "rbxSignal") {
+		const expected = T.func(signalType.args.map((a, i) => ({ name: `arg${i + 1}`, type: a, optional: false })), T.void);
+		const handlerType = prune(checkExpr(c, stmt.handler, expected));
+		checkHandler(c, handlerType, signalType.args, stmt.handler.span);
+		stmt.target = "rbx";
+		return;
+	}
+	if (!isDynamic(signalType)) {
+		c.error("CL3034", stmt.signal.span, `'~>' connects a signal or a Roblox event, not ${typeToString(signalType)}`);
+	}
+	checkExpr(c, stmt.handler);
+	stmt.target = "rbx";
+}
+
+export function checkHandler(c: Checker, handlerType: Type, args: Type[], span: Expr["span"]): void {
+	const h = prune(handlerType);
+	if (h.k !== "func") {
+		if (!isDynamic(h)) {
+			c.error("CL3034", span, `expected a function to handle the event, got ${typeToString(h)}`);
+		}
+		return;
+	}
+	if (h.params.length > args.length && !h.params.slice(args.length).every((p) => p.optional)) {
+		c.error("CL3035", span, `the handler takes ${h.params.length} parameter(s) but the event only passes ${args.length}`, [
+			`event arguments: (${args.map((a) => typeToString(a)).join(", ")})`,
+		]);
+		return;
+	}
+	h.params.forEach((p, i) => {
+		const arg = args[i];
+		if (!arg) {
+			return;
+		}
+		const pt = prune(p.type);
+		if (pt.k === "infer" && !pt.resolved) {
+			pt.resolved = arg;
+			return;
+		}
+		const r = assignable(c, p.type, arg);
+		if (r === "no") {
+			c.error("CL3036", span, `handler parameter '${p.name}' is ${typeToString(p.type)}, but the event passes ${typeToString(arg)}`);
+		}
+	});
+}
+
+// ---------- loops that never yield ----------
+
+function checkInfiniteLoop(c: Checker, stmt: Stmt, forever: boolean, body: Stmt[]): void {
+	if (!forever || containsBreak(body) || alwaysExits(c, body) || containsReturn(body)) {
+		return;
+	}
+	if (!mayYield(c, body)) {
+		c.error("CL4020", stmt.span, "this loop never ends and never yields: it freezes the game", [
+			"wait inside it (`task.wait()`, `RunService.Heartbeat.Wait()`) or connect to an event instead",
+		]);
+	}
+}
+
+function containsReturn(body: Stmt[]): boolean {
+	const visit = (s: Stmt): boolean => {
+		switch (s.kind) {
+			case "Return":
+				return true;
+			case "If":
+				return s.then.some(visit) || (s.else ? s.else.some(visit) : false);
+			case "Block":
+				return s.body.some(visit);
+			case "While":
+			case "For":
+			case "ForIn":
+				return s.body.some(visit);
+			case "Try":
+				return s.body.some(visit) || s.handler.some(visit);
+			case "Match":
+				return s.arms.some((a: MatchArm) => a.body.some(visit));
+			case "Switch":
+				return s.cases.some((k) => k.body.some(visit));
+			default:
+				return false;
+		}
+	};
+	return body.some(visit);
+}
+
+export { isNumeric };