cluaupp 1.5.2 → 2.0.0-beta.2

package/src/compiler/checker/exprs.ts

@@ -0,0 +1,805 @@
+/** Expression checking (names, operators, lambdas, async forms). Calls live in calls.ts, members in members.ts. */
+
+import type { Expr, Param } from "../ast.js";
+import { suggest } from "../diagnostics.js";
+import { SERVICE_RULES } from "../roblox/context.js";
+import { isDynamic, isIntLike, isNumeric, isStringLike, isValueTable, nonNull, prune, T, typeToString, type Type } from "../types.js";
+import { checkCall, checkNew } from "./calls.js";
+import { widenLiteral, type Checker, type FnCtx } from "./checker.js";
+import { checkStatement } from "./statements.js";
+import { conditionNarrowings } from "./flow.js";
+import { checkAssignTarget, checkMember, checkScopeAccess } from "./members.js";
+import type { Sym } from "./symbols.js";
+import { assignable, join } from "./typeops.js";
+
+/** CL++ builtins that are always in scope. */
+export const BUILTINS = new Set([
+	"len", "list", "push", "pop", "insert", "remove", "find", "sort", "args", "array", "dictionary", "mutex", "lock",
+	"unlock", "fetch_add", "atomic_load", "actor", "Some", "Ok", "Err", "int", "float", "bool", "GetService",
+]);
+
+/** Luau libraries (need `@clpp.roblox`, except the ones CL++ itself has). */
+const LIBRARIES = new Set(["math", "string", "table", "task", "coroutine", "bit32", "utf8", "buffer", "os", "debug", "vector"]);
+const CORE_LIBRARIES = new Set(["task", "coroutine"]);
+
+export function checkExpr(c: Checker, e: Expr, expected?: Type, keepTuple = false): Type {
+	let t = checkExprInner(c, e, expected);
+	const p = prune(t);
+	if (p.k === "tuple" && !keepTuple && !(expected && prune(expected).k === "tuple")) {
+		// Luau keeps the first value of a multi-return in a single-value position.
+		t = p.elems[0] ?? T.void;
+	}
+	e.ty = t;
+	return t;
+}
+
+/** A condition: any value works (CL++ truthiness), but not `void`. */
+export function checkCondition(c: Checker, e: Expr): Type {
+	const t = checkExpr(c, e);
+	const p = prune(t);
+	if (p.k === "void") {
+		c.error("CL3013", e.span, "this expression has no value to test");
+	} else if (p.k === "instance" || p.k === "datatype" || p.k === "func") {
+		// always truthy unless nullable — almost always a forgotten comparison
+		c.warn("CL3041", e.span, `${typeToString(p)} is always true here`, ["compare it explicitly, e.g. `x != null`"]);
+	}
+	return t;
+}
+
+/** Narrowing key for a readable path: `s12`, `s12.Character`, `self.hp`. */
+export function exprPathKey(e: Expr): string | null {
+	switch (e.kind) {
+		case "Name":
+			if (e.res && (e.res.kind === "local" || e.res.kind === "const")) {
+				const sym = (e.res as { sym?: { id: number } }).sym;
+				return sym ? `s${sym.id}` : null;
+			}
+			return null;
+		case "SelfField":
+			return `self.${e.name}`;
+		case "Member": {
+			const base = exprPathKey(e.object);
+			if (!base) {
+				if (e.object.res?.kind === "service") {
+					return `svc:${e.object.res.service}.${e.name}`;
+				}
+				return null;
+			}
+			return `${base}.${e.name}`;
+		}
+		default:
+			return null;
+	}
+}
+
+/** Symbol at the root of a place (`p` in `p.stats.hp`). */
+export function rootSymbol(e: Expr): Sym | null {
+	switch (e.kind) {
+		case "Name":
+			return e.res && (e.res.kind === "local" || e.res.kind === "signal" || e.res.kind === "func") ? (e.res.sym as Sym) : null;
+		case "Member":
+		case "Index":
+			return rootSymbol(e.object);
+		default:
+			return null;
+	}
+}
+
+function applyNarrowing(c: Checker, e: Expr, t: Type): Type {
+	const key = exprPathKey(e);
+	if (!key) {
+		return t;
+	}
+	const narrowed = c.scope.narrowedType(key);
+	if (narrowed) {
+		e.narrowedFrom = t;
+		return narrowed;
+	}
+	return t;
+}
+
+function checkExprInner(c: Checker, e: Expr, expected?: Type): Type {
+	switch (e.kind) {
+		case "Number":
+			return e.isFloat ? T.float : T.int;
+		case "String": {
+			const ex = expected ? prune(expected) : null;
+			if (ex && (ex.k === "lit" || (ex.k === "union" && ex.members.some((m) => prune(m).k === "lit")) || (ex.k === "option" && prune(ex.inner).k === "union"))) {
+				return { k: "lit", value: e.value };
+			}
+			return T.string;
+		}
+		case "Template":
+			for (const part of e.parts) {
+				if (typeof part !== "string") {
+					const t = checkExpr(c, part);
+					if (prune(t).k === "void") {
+						c.error("CL3013", part.span, "this expression has no value to interpolate");
+					}
+				}
+			}
+			return T.string;
+		case "Bool":
+			return T.bool;
+		case "Null":
+			return T.null;
+		case "Name":
+			return checkName(c, e, expected);
+		case "SelfField":
+			return checkSelfField(c, e);
+		case "Member":
+			return applyNarrowing(c, e, checkMember(c, e, expected));
+		case "Scope":
+			return checkScopeAccess(c, e);
+		case "Index":
+			return checkIndex(c, e);
+		case "Call":
+			return checkCall(c, e, expected);
+		case "New":
+			return checkNew(c, e, expected);
+		case "Unary":
+			return checkUnary(c, e);
+		case "Binary":
+			return checkBinary(c, e, expected);
+		case "Ternary": {
+			checkCondition(c, e.cond);
+			const a = checkExpr(c, e.then, expected);
+			const b = checkExpr(c, e.else, expected);
+			return join(c, widenLiteral(a), widenLiteral(b));
+		}
+		case "Function":
+			return checkFunctionExpr(c, e, expected);
+		case "Spawn":
+		case "Thread": {
+			const inner = e.kind === "Spawn" ? e.call : e.call;
+			if (inner.kind !== "Call") {
+				c.error("CL3050", inner.span, `${e.kind === "Spawn" ? "spawn" : "thread"} needs a function call: \`${e.kind === "Spawn" ? "spawn" : "thread"} work(x)\``);
+			}
+			const t = prune(checkExpr(c, inner));
+			if (e.kind === "Thread") {
+				c.warn("CL3051", e.span, "Roblox has no native threads; `thread` runs the call as a task on the same thread", ["use an Actor for real parallel work"]);
+			}
+			return { k: "task", result: t.k === "task" ? t.result : t };
+		}
+		case "Await":
+			return checkAwait(c, e);
+		case "Join": {
+			const t = prune(checkExpr(c, e.operand));
+			c.noteYield();
+			if (t.k === "task") {
+				return t.result;
+			}
+			if (!isDynamic(t)) {
+				c.error("CL3052", e.operand.span, `join needs a thread/task, got ${typeToString(t)}`);
+			}
+			return T.any;
+		}
+		case "Move": {
+			const t = checkExpr(c, e.operand);
+			if (e.operand.kind !== "Name") {
+				c.error("CL3053", e.operand.span, "move(...) takes a variable");
+			} else if (e.operand.res?.kind === "local") {
+				const sym = e.operand.res.sym as Sym;
+				if (!sym.mutable) {
+					c.error("CL3054", e.operand.span, `cannot move out of the immutable '${sym.name}'`, ["declare it with `let mut`"]);
+				}
+				sym.assigned = true;
+			}
+			return t;
+		}
+		case "PCall":
+			checkExpr(c, e.operand);
+			return T.int;
+		case "Parallel": {
+			let elem: Type = T.never;
+			for (const call of e.calls) {
+				const t = prune(checkExpr(c, call));
+				const r = t.k === "task" ? t.result : t;
+				elem = join(c, elem, r);
+			}
+			c.noteYield();
+			return T.list(prune(elem).k === "never" ? T.any : elem);
+		}
+		case "Update":
+			return checkUpdate(c, e);
+		case "Cast":
+			return checkCast(c, e);
+		case "Error":
+			return T.unknown;
+		default:
+			return T.unknown;
+	}
+}
+
+// ---------- names ----------
+
+function checkName(c: Checker, e: Extract<Expr, { kind: "Name" }>, expected?: Type): Type {
+	const sym = c.scope.lookup(e.name);
+	if (sym) {
+		sym.used = true;
+		if (c.fn && sym.depth < c.fn.depth && (sym.kind === "var" || sym.kind === "param" || sym.kind === "self" || sym.kind === "signal" || sym.kind === "const")) {
+			sym.captured = true;
+		}
+		switch (sym.kind) {
+			case "var":
+			case "param":
+			case "self":
+				e.res = { kind: "local", sym };
+				return applyNarrowing(c, e, sym.type);
+			case "const":
+				if (sym.constValue !== undefined) {
+					e.res = { kind: "const", value: sym.constValue };
+				} else {
+					e.res = { kind: "local", sym };
+				}
+				return sym.type;
+			case "func":
+				e.res = { kind: "func", sym };
+				if (sym.decl && prune((sym.type as Extract<Type, { k: "func" }>).ret).k === "infer" && !c.isChecking(sym.decl)) {
+					// the value of a function needs its inferred return type
+				}
+				return sym.type;
+			case "signal":
+				e.res = { kind: "signal", sym };
+				return sym.type;
+			case "module":
+				e.res = { kind: "module", alias: sym.name, moduleId: (sym.type as { ns?: { moduleId?: string } }).ns?.moduleId ?? sym.name };
+				return sym.type;
+			case "struct":
+				e.res = { kind: "struct", name: sym.name, sym };
+				return sym.type;
+			case "enum":
+				e.res = { kind: "enum", name: sym.name, sym };
+				return sym.type;
+			case "variant":
+				e.res = { kind: "builtin", name: "variant" };
+				return sym.type;
+			case "namespace":
+				e.res = { kind: "module", alias: sym.name, moduleId: "namespace" };
+				return sym.type;
+			default:
+				e.res = { kind: "local", sym };
+				return sym.type;
+		}
+	}
+	return resolveGlobalName(c, e, expected);
+}
+
+function resolveGlobalName(c: Checker, e: Extract<Expr, { kind: "Name" }>, expected?: Type): Type {
+	const name = e.name;
+	if (name === "self") {
+		c.error("CL2005", e.span, "'self' only exists inside a struct method");
+		return T.unknown;
+	}
+	if (name === "None") {
+		e.res = { kind: "builtin", name: "None" };
+		return expected && prune(expected).k === "option" ? expected : T.null;
+	}
+	if (BUILTINS.has(name)) {
+		e.res = { kind: "builtin", name };
+		return T.func([], T.any);
+	}
+	if (name === "Vector2" || name === "Vector3") {
+		e.res = { kind: "global", luau: name };
+		return { k: "namespace", ns: { kind: "datatype", name } };
+	}
+	if (name === "string" || name === "type") {
+		// `string(x)` conversion / `string.format` / `type(x)` are handled by callers; as a value it is the library.
+	}
+	if (LIBRARIES.has(name)) {
+		if (!CORE_LIBRARIES.has(name)) {
+			c.requireRoblox(e.span, name);
+		}
+		e.res = { kind: "global", luau: name };
+		return { k: "namespace", ns: { kind: "library", name } };
+	}
+	const api = c.api;
+	switch (name) {
+		case "game":
+			c.requireRoblox(e.span, name);
+			e.res = { kind: "dataModel" };
+			return { k: "instance", cls: "DataModel", ...(c.input.dataModel ? { dm: c.input.dataModel } : {}) };
+		case "workspace":
+		case "Workspace":
+			c.requireRoblox(e.span, name);
+			e.res = { kind: "global", luau: "workspace" };
+			return { k: "instance", cls: "Workspace", ...(c.input.dataModel?.children.get("Workspace") ? { dm: c.input.dataModel.children.get("Workspace") } : {}) };
+		case "script":
+			c.requireRoblox(e.span, name);
+			e.res = { kind: "global", luau: "script" };
+			return T.instance(c.input.kind === "module" ? "ModuleScript" : c.input.context === "client" ? "LocalScript" : "Script");
+		case "plugin":
+			c.requireRoblox(e.span, name);
+			if (c.input.context !== "plugin") {
+				c.error("CTX6003", e.span, "'plugin' only exists in plugin scripts");
+			}
+			e.res = { kind: "global", luau: "plugin" };
+			return T.option(T.instance("Plugin"));
+		case "shared":
+			c.requireRoblox(e.span, name);
+			e.res = { kind: "global", luau: "shared" };
+			return T.any;
+		case "Enum":
+			c.requireRoblox(e.span, name);
+			e.res = { kind: "global", luau: "Enum" };
+			return { k: "rbxEnums" };
+		case "Instance":
+			c.requireRoblox(e.span, name);
+			e.res = { kind: "global", luau: "Instance" };
+			return { k: "namespace", ns: { kind: "instanceStatic" } };
+		default:
+			break;
+	}
+	if (api.isService(name)) {
+		c.useService(name, e.span);
+		const rule = SERVICE_RULES[name];
+		if (rule) {
+			c.checkContext(rule.only, e.span, name, rule.why, rule.severity);
+		}
+		const cls = api.classes[name];
+		if (cls.deprecated) {
+			c.warn("RBX5010", e.span, `${name} is deprecated`);
+		}
+		e.res = { kind: "service", service: name };
+		return { k: "instance", cls: name, ...(c.input.dataModel?.children.get(name) ? { dm: c.input.dataModel.children.get(name) } : {}) };
+	}
+	if (api.hasDatatype(name)) {
+		c.requireRoblox(e.span, name);
+		e.res = { kind: "global", luau: name };
+		return { k: "namespace", ns: { kind: "datatype", name } };
+	}
+	const global = api.globals[name];
+	if (global) {
+		c.requireRoblox(e.span, name);
+		if (global.deprecated) {
+			const use = typeof global.deprecated === "string" ? global.deprecated : null;
+			c.warn("RBX5011", e.span, `${name}() is deprecated${use ? `; use ${use}` : ""}`, use ? [`${use} is faster and more precise`] : undefined);
+		}
+		e.res = { kind: "global", luau: name };
+		return api.globalFunction(name) ?? T.any;
+	}
+	if (api.hasClass(name)) {
+		c.requireRoblox(e.span, name);
+		c.error("RBX5012", e.span, `${name} is a Roblox class, not a value`, [`create one with \`${name}()\` or \`Instance.new("${name}")\``]);
+		return T.unknown;
+	}
+	const candidates = c.scope.allValueNames();
+	const s = suggest(name, [...candidates, ...BUILTINS]);
+	const notes: string[] = [];
+	if (s) {
+		notes.push(`did you mean '${s}'?`);
+	}
+	c.error("CL2001", e.span, `undefined name '${name}'`, notes.length ? notes : undefined);
+	return T.unknown;
+}
+
+function checkSelfField(c: Checker, e: Extract<Expr, { kind: "SelfField" }>): Type {
+	const fn = c.fn;
+	if (fn && fn.isMethod && fn.structId) {
+		const info = c.structs.get(fn.structId);
+		const field = info?.fields.find((f) => f.name === e.name);
+		if (field) {
+			if (fn.selfSym) {
+				fn.selfSym.used = true;
+				if (c.fn && fn.selfSym.depth < c.fn.depth) {
+					fn.selfSym.captured = true;
+				}
+			}
+			e.res = { kind: "field", struct: fn.structId };
+			const key = `self.${e.name}`;
+			const narrowed = c.scope.narrowedType(key);
+			if (narrowed) {
+				e.narrowedFrom = field.type;
+				return narrowed;
+			}
+			return field.type;
+		}
+		const method = info?.methods.get(e.name);
+		if (method) {
+			e.res = { kind: "method", struct: fn.structId, name: e.name, isStatic: method.isStatic };
+			return method.type;
+		}
+		if (e.name !== "game" && e.name !== "workspace") {
+			const s = info ? suggest(e.name, [...info.fields.map((f) => f.name), ...info.methods.keys()]) : null;
+			c.error("CL2006", e.nameSpan, `${info?.name ?? "this struct"} has no field '${e.name}'`, s ? [`did you mean '@${s}'?`] : undefined);
+			return T.unknown;
+		}
+	}
+	if (e.name === "game") {
+		c.requireRoblox(e.span, "@game");
+		e.res = { kind: "dataModel" };
+		return { k: "instance", cls: "DataModel", ...(c.input.dataModel ? { dm: c.input.dataModel } : {}) };
+	}
+	if (e.name === "workspace") {
+		c.requireRoblox(e.span, "@workspace");
+		e.res = { kind: "global", luau: "workspace" };
+		return T.instance("Workspace");
+	}
+	c.usesShared = true;
+	e.res = { kind: "sharedField", name: e.name };
+	return T.any;
+}
+
+// ---------- indexing ----------
+
+function checkIndex(c: Checker, e: Extract<Expr, { kind: "Index" }>): Type {
+	const objType = prune(checkExpr(c, e.object));
+	if (e.index.kind === "Binary" && e.index.op === "..") {
+		const a = checkExpr(c, e.index.left);
+		const b = checkExpr(c, e.index.right);
+		e.index.ty = T.any;
+		for (const [t, x] of [[a, e.index.left], [b, e.index.right]] as const) {
+			if (!isIntLike(t) && !isDynamic(t)) {
+				c.error("CL3060", x.span, `slice bounds must be int, got ${typeToString(t)}`);
+			}
+		}
+		if (objType.k === "list" || objType.k === "string" || isDynamic(objType) || (objType.k === "lit" && typeof objType.value === "string")) {
+			return objType.k === "lit" ? T.string : objType;
+		}
+		c.error("CL3061", e.object.span, `cannot slice ${typeToString(objType)}`);
+		return T.unknown;
+	}
+	const indexType = checkExpr(c, e.index);
+	switch (objType.k) {
+		case "list":
+			if (!isIntLike(indexType) && !isDynamic(indexType)) {
+				c.error("CL3060", e.index.span, `list index must be int, got ${typeToString(indexType)}`, isNumeric(indexType) ? ["convert with int(...)"] : undefined);
+			}
+			if ((e.index.kind === "Number" && e.index.value < 0) || (e.index.kind === "Unary" && e.index.op === "-" && e.index.operand.kind === "Number")) {
+				c.error("CL3062", e.index.span, "negative index: CL++ lists start at 0");
+			}
+			return objType.elem;
+		case "string":
+		case "lit":
+			if (!isIntLike(indexType) && !isDynamic(indexType)) {
+				c.error("CL3060", e.index.span, `text index must be int, got ${typeToString(indexType)}`);
+			}
+			return T.string;
+		case "dict":
+			if (assignable(c, objType.key, indexType) === "no") {
+				c.error("CL3063", e.index.span, `dictionary key must be ${typeToString(objType.key)}, got ${typeToString(indexType)}`);
+			}
+			return objType.value;
+		case "table": {
+			if (e.index.kind === "String") {
+				const f = objType.fields[e.index.value];
+				if (f) {
+					return f;
+				}
+			}
+			return T.any;
+		}
+		case "tuple":
+			if (e.index.kind === "Number" && Number.isInteger(e.index.value)) {
+				return objType.elems[e.index.value] ?? T.unknown;
+			}
+			return T.any;
+		case "instance":
+			if (!isStringLike(indexType)) {
+				c.error("CL3064", e.index.span, `${objType.cls}[…] needs a child name (string)`);
+			}
+			return T.option(T.instance("Instance"));
+		case "buffer":
+			c.error("CL3065", e.span, "read buffers with buffer.readu8(b, offset) and friends");
+			return T.int;
+		case "option":
+			c.strictError("CL3011", e.object.span, `${typeToString(objType)} may be null; check it before indexing`);
+			return T.any;
+		case "any":
+		case "unknown":
+		case "infer":
+			return T.any;
+		default:
+			c.error("CL3066", e.span, `cannot index ${typeToString(objType)}`);
+			return T.unknown;
+	}
+}
+
+// ---------- operators ----------
+
+function checkUnary(c: Checker, e: Extract<Expr, { kind: "Unary" }>): Type {
+	const t = prune(checkExpr(c, e.operand));
+	if (e.loose && (e.op === "-" || e.op === "~") && e.operand.kind === "Binary" && e.operand.op !== "and" && e.operand.op !== "or") {
+		c.warn("CL1203", e.span, `unary '${e.op}' applies to the whole '${e.operand.op}' expression (CL++ precedence)`, [
+			`this is ${e.op}(a ${e.operand.op} b); write (${e.op}a) ${e.operand.op} b if you meant only the left side`,
+		]);
+	}
+	switch (e.op) {
+		case "-":
+			if (isNumeric(t)) {
+				return widenLiteral(t);
+			}
+			if (t.k === "datatype" && c.api.unaryMinus(t)) {
+				return t;
+			}
+			if (!isDynamic(t)) {
+				c.error("CL3070", e.span, `cannot negate ${typeToString(t)}`);
+			}
+			return isDynamic(t) ? T.float : T.unknown;
+		case "~":
+			if (!isIntLike(t) && !isDynamic(t)) {
+				c.error("CL3071", e.span, `'~' needs an int, got ${typeToString(t)}`);
+			}
+			return T.int;
+		case "not":
+			if (t.k === "void") {
+				c.error("CL3013", e.operand.span, "this expression has no value to test");
+			}
+			return T.bool;
+		default:
+			return T.unknown;
+	}
+}
+
+function checkBinary(c: Checker, e: Extract<Expr, { kind: "Binary" }>, expected?: Type): Type {
+	const op = e.op;
+	if (op === "and" || op === "or") {
+		const l = prune(checkExpr(c, e.left));
+		// `a and b`: b is only evaluated when a holds, so it sees a's narrowings.
+		const scope = c.pushScope("block");
+		if (op === "and") {
+			for (const [k, v] of narrowingsOf(c, e.left, true)) {
+				scope.narrowed.set(k, v);
+			}
+		} else {
+			for (const [k, v] of narrowingsOf(c, e.left, false)) {
+				scope.narrowed.set(k, v);
+			}
+		}
+		const r = prune(checkExpr(c, e.right, op === "or" ? expected : undefined));
+		c.popScope();
+		if (op === "or" && (l.k === "option" || ((l.k === "instance" || l.k === "any") && r.k !== "bool"))) {
+			// Luau value-or: `FindFirstChild("A") or FindFirstChild("B")`, `name or "guest"`
+			e.res = { kind: "builtin", name: "valueOr" };
+			return join(c, nonNull(l), r);
+		}
+		return T.bool;
+	}
+	const l = prune(checkExpr(c, e.left));
+	const r = prune(checkExpr(c, e.right, op === "==" || op === "!=" ? l : undefined));
+	switch (op) {
+		case ".:":
+			for (const [t, x] of [[l, e.left], [r, e.right]] as const) {
+				if (t.k === "void") {
+					c.error("CL3013", x.span, "this expression has no value to join");
+				}
+			}
+			return T.string;
+		case "..":
+			c.error("CL3072", e.opSpan, "'..' makes a slice range and only works inside `x[a .. b]`", ["join text with `.:`"]);
+			return T.unknown;
+		case "+":
+		case "-":
+		case "*":
+		case "/":
+		case "%":
+			return arithmetic(c, e, l, r);
+		case "==":
+		case "!=":
+			comparable(c, e, l, r);
+			return T.bool;
+		case "<":
+		case "<=":
+		case ">":
+		case ">=":
+			if ((isNumeric(l) && isNumeric(r)) || (isStringLike(l) && isStringLike(r)) || isDynamic(l) || isDynamic(r) || l.k === "param" || r.k === "param") {
+				return T.bool;
+			}
+			if (l.k === "option" || r.k === "option") {
+				c.strictError("CL3011", e.span, "comparing a value that may be null");
+				return T.bool;
+			}
+			c.error("CL3073", e.opSpan, `cannot order ${typeToString(l)} and ${typeToString(r)} with '${op}'`);
+			return T.bool;
+		case "&":
+		case "|":
+		case "^":
+		case "shl":
+		case "shr":
+			for (const [t, x] of [[l, e.left], [r, e.right]] as const) {
+				if (!isIntLike(t) && !isDynamic(t)) {
+					c.error("CL3074", x.span, `'${op}' works on ints, got ${typeToString(t)}`);
+				}
+			}
+			return T.int;
+		default:
+			return T.unknown;
+	}
+}
+
+function narrowingsOf(c: Checker, e: Expr, truthy: boolean): Array<[string, Type]> {
+	return conditionNarrowings(c, e, truthy);
+}
+
+function arithmetic(c: Checker, e: Extract<Expr, { kind: "Binary" }>, l: Type, r: Type): Type {
+	const op = e.op;
+	if (isNumeric(l) && isNumeric(r)) {
+		if (isIntLike(l) && isIntLike(r) && l.k !== "enum" && r.k !== "enum") {
+			if (op === "/" && e.right.kind === "Number" && e.right.value === 0) {
+				c.error("CL3075", e.right.span, "division by zero");
+			}
+			return T.int;
+		}
+		return T.float;
+	}
+	if (l.k === "param" || r.k === "param") {
+		return l.k === "param" ? l : r;
+	}
+	if (isDynamic(l) || isDynamic(r)) {
+		if (l.k === "datatype" || r.k === "datatype") {
+			return l.k === "datatype" ? l : r;
+		}
+		return isDynamic(l) && isDynamic(r) ? T.any : T.float;
+	}
+	if (l.k === "datatype" || r.k === "datatype") {
+		const result = c.api.operator(op, l, r);
+		if (result) {
+			return result;
+		}
+		c.error("CL3076", e.opSpan, `'${op}' is not defined for ${typeToString(l)} and ${typeToString(r)}`);
+		return T.unknown;
+	}
+	if (l.k === "struct" && (op === "+" || op === "-")) {
+		const fn = c.scope.lookup(`operator${op}`);
+		if (fn && fn.kind === "func") {
+			fn.used = true;
+			e.res = { kind: "func", sym: fn };
+			return prune((fn.type as Extract<Type, { k: "func" }>).ret);
+		}
+	}
+	if (op === "+" && (isStringLike(l) || isStringLike(r))) {
+		c.error("CL3077", e.opSpan, "text is joined with `.:` in CL++, not `+`", [`"a" .: b`]);
+		return T.string;
+	}
+	if (l.k === "option" || r.k === "option") {
+		c.strictError("CL3011", e.span, `arithmetic on a value that may be null`);
+		return T.float;
+	}
+	c.error("CL3078", e.opSpan, `'${op}' needs numbers, got ${typeToString(l)} and ${typeToString(r)}`);
+	return T.unknown;
+}
+
+function comparable(c: Checker, e: Extract<Expr, { kind: "Binary" }>, l: Type, r: Type): void {
+	if (isDynamic(l) || isDynamic(r) || l.k === "null" || r.k === "null") {
+		if ((l.k === "null" && isPlainValue(r)) || (r.k === "null" && isPlainValue(l))) {
+			const other = l.k === "null" ? r : l;
+			c.warn("CL3042", e.span, `${typeToString(other)} is never null, so this is always ${e.op === "==" ? "false" : "true"}`);
+		}
+		return;
+	}
+	if (assignable(c, widenLiteral(l), r) !== "no" || assignable(c, widenLiteral(r), l) !== "no") {
+		if (l.k === "lit" && r.k === "lit" && l.value !== r.value) {
+			c.warn("CL3043", e.span, `this comparison is always ${e.op === "==" ? "false" : "true"}`);
+		}
+		return;
+	}
+	if (isNumeric(l) && isNumeric(r)) {
+		return;
+	}
+	c.error("CL3044", e.span, `${typeToString(l)} and ${typeToString(r)} can never be equal`);
+}
+
+function isPlainValue(t: Type): boolean {
+	const p = prune(t);
+	return p.k === "int" || p.k === "float" || p.k === "bool" || p.k === "string" || p.k === "datatype" || p.k === "lit" || isValueTable(p);
+}
+
+function checkUpdate(c: Checker, e: Extract<Expr, { kind: "Update" }>): Type {
+	const target = checkAssignTarget(c, e.target, true);
+	const t = prune(target.type);
+	if (!isNumeric(t) && !isDynamic(t)) {
+		c.error("CL3079", e.span, `'${e.delta > 0 ? "++" : "--"}' needs a number, got ${typeToString(t)}`);
+	}
+	const key = exprPathKey(e.target);
+	if (key) {
+		c.scope.invalidate(key);
+	}
+	e.target.ty = target.type;
+	return widenLiteral(t);
+}
+
+function checkCast(c: Checker, e: Extract<Expr, { kind: "Cast" }>): Type {
+	const from = prune(checkExpr(c, e.operand));
+	const to = c.resolveType(e.type);
+	const target = prune(to);
+	if (isDynamic(from) || isDynamic(target)) {
+		return to;
+	}
+	const base = from.k === "option" ? prune(from.inner) : from;
+	if (assignable(c, target, base) === "ok") {
+		return to;
+	}
+	if (base.k === "instance" && target.k === "instance" && c.api.isA(target.cls, base.cls)) {
+		return to; // downcast: WaitForChild("Map") as Model
+	}
+	if (assignable(c, base, target) === "ok") {
+		return to;
+	}
+	c.error("CL3080", e.span, `cannot convert ${typeToString(from)} to ${typeToString(target)}`, isNumeric(base) || isNumeric(target) ? ["convert numbers with int(x) / float(x) / string(x)"] : undefined);
+	return to;
+}
+
+function checkAwait(c: Checker, e: Extract<Expr, { kind: "Await" }>): Type {
+	const t = prune(checkExpr(c, e.operand));
+	c.noteYield();
+	if (t.k === "task") {
+		return t.result;
+	}
+	if (t.k === "rbxSignal") {
+		// await part.Touched → part.Touched:Wait()
+		return t.args.length === 0 ? T.void : t.args.length === 1 ? t.args[0] : { k: "tuple", elems: t.args };
+	}
+	if (!isDynamic(t)) {
+		c.warn("CL3055", e.operand.span, `await on ${typeToString(t)} does nothing`, ["await a task, an async call or a Roblox event"]);
+	}
+	return t;
+}
+
+// ---------- functions as values ----------
+
+export function checkFunctionExpr(c: Checker, e: Extract<Expr, { kind: "Function" }>, expected?: Type): Type {
+	const exp = expected ? prune(expected) : null;
+	const expFn = exp && exp.k === "func" ? exp : exp && exp.k === "option" && prune(exp.inner).k === "func" ? (prune(exp.inner) as Extract<Type, { k: "func" }>) : null;
+	const outer = c.fn;
+	const declaredRet = e.returnType ? c.resolveType(e.returnType) : null;
+	const ctx: FnCtx = {
+		decl: null,
+		declaredRet,
+		returns: [],
+		depth: (outer?.depth ?? 0) + 1,
+		isMethod: outer?.isMethod ?? false,
+		structId: outer?.structId ?? null,
+		selfSym: outer?.selfSym ?? null,
+		isAsync: false,
+		yields: false,
+		mutatesSelf: false,
+		contextOnly: outer?.contextOnly,
+		isParallel: false,
+		sym: null,
+	};
+	c.fn = ctx;
+	c.pushScope("function");
+	const params = e.params.map((p: Param, i) => {
+		let t: Type;
+		if (p.type) {
+			t = c.resolveType(p.type);
+			const want = expFn?.params[i]?.type;
+			if (want && assignable(c, t, want) === "no" && !isDynamic(want)) {
+				c.error("CL3036", p.span, `parameter '${p.name}' is ${typeToString(t)}, but ${typeToString(want)} is passed here`);
+			}
+		} else if (expFn && expFn.params[i]) {
+			t = expFn.params[i].type;
+		} else if (p.variadic && expFn?.variadic) {
+			t = T.list(expFn.variadic);
+		} else {
+			t = { k: "infer", resolved: null };
+		}
+		p.ty = p.variadic && !p.type && !expFn?.variadic ? T.list(T.any) : t;
+		return { name: p.name, type: t, optional: p.defaultValue !== null };
+	});
+	c.declareParams(e.params);
+	let ret: Type;
+	if (Array.isArray(e.body)) {
+		for (const s of e.body) {
+			checkStatement(c, s);
+		}
+		c.finishFunction(ctx, e.body, e.span, "function");
+		ret = declaredRet ?? (ctx.returns.length ? ctx.returns.reduce((a, b) => join(c, a, b)) : T.void);
+	} else {
+		const t = checkExpr(c, e.body, expFn?.ret);
+		c.markCopy(e.body);
+		ret = declaredRet ?? widenLiteral(t);
+		if (declaredRet) {
+			c.expectAssignable(declaredRet, t, e.body.span, "cannot return this value");
+		}
+	}
+	c.popScope();
+	c.fn = outer;
+	e.fn = { mayYield: ctx.yields };
+	if (ctx.mutatesSelf && outer) {
+		outer.mutatesSelf = true;
+	}
+	return T.func(params, ret);
+}
+
+export { BUILTINS as CL_BUILTINS };