cluaupp 1.5.2 → 2.0.0-beta.2

package/generated/compiler/checker/exprs.js

@@ -0,0 +1,791 @@
+"use strict";
+/** Expression checking (names, operators, lambdas, async forms). Calls live in calls.ts, members in members.ts. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CL_BUILTINS = exports.BUILTINS = void 0;
+exports.checkExpr = checkExpr;
+exports.checkCondition = checkCondition;
+exports.exprPathKey = exprPathKey;
+exports.rootSymbol = rootSymbol;
+exports.checkFunctionExpr = checkFunctionExpr;
+const diagnostics_js_1 = require("../diagnostics.js");
+const context_js_1 = require("../roblox/context.js");
+const types_js_1 = require("../types.js");
+const calls_js_1 = require("./calls.js");
+const checker_js_1 = require("./checker.js");
+const statements_js_1 = require("./statements.js");
+const flow_js_1 = require("./flow.js");
+const members_js_1 = require("./members.js");
+const typeops_js_1 = require("./typeops.js");
+/** CL++ builtins that are always in scope. */
+exports.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",
+]);
+exports.CL_BUILTINS = exports.BUILTINS;
+/** 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"]);
+function checkExpr(c, e, expected, keepTuple = false) {
+    let t = checkExprInner(c, e, expected);
+    const p = (0, types_js_1.prune)(t);
+    if (p.k === "tuple" && !keepTuple && !(expected && (0, types_js_1.prune)(expected).k === "tuple")) {
+        // Luau keeps the first value of a multi-return in a single-value position.
+        t = p.elems[0] ?? types_js_1.T.void;
+    }
+    e.ty = t;
+    return t;
+}
+/** A condition: any value works (CL++ truthiness), but not `void`. */
+function checkCondition(c, e) {
+    const t = checkExpr(c, e);
+    const p = (0, types_js_1.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, `${(0, types_js_1.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`. */
+function exprPathKey(e) {
+    switch (e.kind) {
+        case "Name":
+            if (e.res && (e.res.kind === "local" || e.res.kind === "const")) {
+                const sym = e.res.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`). */
+function rootSymbol(e) {
+    switch (e.kind) {
+        case "Name":
+            return e.res && (e.res.kind === "local" || e.res.kind === "signal" || e.res.kind === "func") ? e.res.sym : null;
+        case "Member":
+        case "Index":
+            return rootSymbol(e.object);
+        default:
+            return null;
+    }
+}
+function applyNarrowing(c, e, t) {
+    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, e, expected) {
+    switch (e.kind) {
+        case "Number":
+            return e.isFloat ? types_js_1.T.float : types_js_1.T.int;
+        case "String": {
+            const ex = expected ? (0, types_js_1.prune)(expected) : null;
+            if (ex && (ex.k === "lit" || (ex.k === "union" && ex.members.some((m) => (0, types_js_1.prune)(m).k === "lit")) || (ex.k === "option" && (0, types_js_1.prune)(ex.inner).k === "union"))) {
+                return { k: "lit", value: e.value };
+            }
+            return types_js_1.T.string;
+        }
+        case "Template":
+            for (const part of e.parts) {
+                if (typeof part !== "string") {
+                    const t = checkExpr(c, part);
+                    if ((0, types_js_1.prune)(t).k === "void") {
+                        c.error("CL3013", part.span, "this expression has no value to interpolate");
+                    }
+                }
+            }
+            return types_js_1.T.string;
+        case "Bool":
+            return types_js_1.T.bool;
+        case "Null":
+            return types_js_1.T.null;
+        case "Name":
+            return checkName(c, e, expected);
+        case "SelfField":
+            return checkSelfField(c, e);
+        case "Member":
+            return applyNarrowing(c, e, (0, members_js_1.checkMember)(c, e, expected));
+        case "Scope":
+            return (0, members_js_1.checkScopeAccess)(c, e);
+        case "Index":
+            return checkIndex(c, e);
+        case "Call":
+            return (0, calls_js_1.checkCall)(c, e, expected);
+        case "New":
+            return (0, calls_js_1.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 (0, typeops_js_1.join)(c, (0, checker_js_1.widenLiteral)(a), (0, checker_js_1.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 = (0, types_js_1.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 = (0, types_js_1.prune)(checkExpr(c, e.operand));
+            c.noteYield();
+            if (t.k === "task") {
+                return t.result;
+            }
+            if (!(0, types_js_1.isDynamic)(t)) {
+                c.error("CL3052", e.operand.span, `join needs a thread/task, got ${(0, types_js_1.typeToString)(t)}`);
+            }
+            return types_js_1.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;
+                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 types_js_1.T.int;
+        case "Parallel": {
+            let elem = types_js_1.T.never;
+            for (const call of e.calls) {
+                const t = (0, types_js_1.prune)(checkExpr(c, call));
+                const r = t.k === "task" ? t.result : t;
+                elem = (0, typeops_js_1.join)(c, elem, r);
+            }
+            c.noteYield();
+            return types_js_1.T.list((0, types_js_1.prune)(elem).k === "never" ? types_js_1.T.any : elem);
+        }
+        case "Update":
+            return checkUpdate(c, e);
+        case "Cast":
+            return checkCast(c, e);
+        case "Error":
+            return types_js_1.T.unknown;
+        default:
+            return types_js_1.T.unknown;
+    }
+}
+// ---------- names ----------
+function checkName(c, e, expected) {
+    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 && (0, types_js_1.prune)(sym.type.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.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, e, expected) {
+    const name = e.name;
+    if (name === "self") {
+        c.error("CL2005", e.span, "'self' only exists inside a struct method");
+        return types_js_1.T.unknown;
+    }
+    if (name === "None") {
+        e.res = { kind: "builtin", name: "None" };
+        return expected && (0, types_js_1.prune)(expected).k === "option" ? expected : types_js_1.T.null;
+    }
+    if (exports.BUILTINS.has(name)) {
+        e.res = { kind: "builtin", name };
+        return types_js_1.T.func([], types_js_1.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 types_js_1.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 types_js_1.T.option(types_js_1.T.instance("Plugin"));
+        case "shared":
+            c.requireRoblox(e.span, name);
+            e.res = { kind: "global", luau: "shared" };
+            return types_js_1.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 = context_js_1.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) ?? types_js_1.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 types_js_1.T.unknown;
+    }
+    const candidates = c.scope.allValueNames();
+    const s = (0, diagnostics_js_1.suggest)(name, [...candidates, ...exports.BUILTINS]);
+    const notes = [];
+    if (s) {
+        notes.push(`did you mean '${s}'?`);
+    }
+    c.error("CL2001", e.span, `undefined name '${name}'`, notes.length ? notes : undefined);
+    return types_js_1.T.unknown;
+}
+function checkSelfField(c, e) {
+    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 ? (0, diagnostics_js_1.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 types_js_1.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 types_js_1.T.instance("Workspace");
+    }
+    c.usesShared = true;
+    e.res = { kind: "sharedField", name: e.name };
+    return types_js_1.T.any;
+}
+// ---------- indexing ----------
+function checkIndex(c, e) {
+    const objType = (0, types_js_1.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 = types_js_1.T.any;
+        for (const [t, x] of [[a, e.index.left], [b, e.index.right]]) {
+            if (!(0, types_js_1.isIntLike)(t) && !(0, types_js_1.isDynamic)(t)) {
+                c.error("CL3060", x.span, `slice bounds must be int, got ${(0, types_js_1.typeToString)(t)}`);
+            }
+        }
+        if (objType.k === "list" || objType.k === "string" || (0, types_js_1.isDynamic)(objType) || (objType.k === "lit" && typeof objType.value === "string")) {
+            return objType.k === "lit" ? types_js_1.T.string : objType;
+        }
+        c.error("CL3061", e.object.span, `cannot slice ${(0, types_js_1.typeToString)(objType)}`);
+        return types_js_1.T.unknown;
+    }
+    const indexType = checkExpr(c, e.index);
+    switch (objType.k) {
+        case "list":
+            if (!(0, types_js_1.isIntLike)(indexType) && !(0, types_js_1.isDynamic)(indexType)) {
+                c.error("CL3060", e.index.span, `list index must be int, got ${(0, types_js_1.typeToString)(indexType)}`, (0, types_js_1.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 (!(0, types_js_1.isIntLike)(indexType) && !(0, types_js_1.isDynamic)(indexType)) {
+                c.error("CL3060", e.index.span, `text index must be int, got ${(0, types_js_1.typeToString)(indexType)}`);
+            }
+            return types_js_1.T.string;
+        case "dict":
+            if ((0, typeops_js_1.assignable)(c, objType.key, indexType) === "no") {
+                c.error("CL3063", e.index.span, `dictionary key must be ${(0, types_js_1.typeToString)(objType.key)}, got ${(0, types_js_1.typeToString)(indexType)}`);
+            }
+            return objType.value;
+        case "table": {
+            if (e.index.kind === "String") {
+                const f = objType.fields[e.index.value];
+                if (f) {
+                    return f;
+                }
+            }
+            return types_js_1.T.any;
+        }
+        case "tuple":
+            if (e.index.kind === "Number" && Number.isInteger(e.index.value)) {
+                return objType.elems[e.index.value] ?? types_js_1.T.unknown;
+            }
+            return types_js_1.T.any;
+        case "instance":
+            if (!(0, types_js_1.isStringLike)(indexType)) {
+                c.error("CL3064", e.index.span, `${objType.cls}[…] needs a child name (string)`);
+            }
+            return types_js_1.T.option(types_js_1.T.instance("Instance"));
+        case "buffer":
+            c.error("CL3065", e.span, "read buffers with buffer.readu8(b, offset) and friends");
+            return types_js_1.T.int;
+        case "option":
+            c.strictError("CL3011", e.object.span, `${(0, types_js_1.typeToString)(objType)} may be null; check it before indexing`);
+            return types_js_1.T.any;
+        case "any":
+        case "unknown":
+        case "infer":
+            return types_js_1.T.any;
+        default:
+            c.error("CL3066", e.span, `cannot index ${(0, types_js_1.typeToString)(objType)}`);
+            return types_js_1.T.unknown;
+    }
+}
+// ---------- operators ----------
+function checkUnary(c, e) {
+    const t = (0, types_js_1.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 ((0, types_js_1.isNumeric)(t)) {
+                return (0, checker_js_1.widenLiteral)(t);
+            }
+            if (t.k === "datatype" && c.api.unaryMinus(t)) {
+                return t;
+            }
+            if (!(0, types_js_1.isDynamic)(t)) {
+                c.error("CL3070", e.span, `cannot negate ${(0, types_js_1.typeToString)(t)}`);
+            }
+            return (0, types_js_1.isDynamic)(t) ? types_js_1.T.float : types_js_1.T.unknown;
+        case "~":
+            if (!(0, types_js_1.isIntLike)(t) && !(0, types_js_1.isDynamic)(t)) {
+                c.error("CL3071", e.span, `'~' needs an int, got ${(0, types_js_1.typeToString)(t)}`);
+            }
+            return types_js_1.T.int;
+        case "not":
+            if (t.k === "void") {
+                c.error("CL3013", e.operand.span, "this expression has no value to test");
+            }
+            return types_js_1.T.bool;
+        default:
+            return types_js_1.T.unknown;
+    }
+}
+function checkBinary(c, e, expected) {
+    const op = e.op;
+    if (op === "and" || op === "or") {
+        const l = (0, types_js_1.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 = (0, types_js_1.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 (0, typeops_js_1.join)(c, (0, types_js_1.nonNull)(l), r);
+        }
+        return types_js_1.T.bool;
+    }
+    const l = (0, types_js_1.prune)(checkExpr(c, e.left));
+    const r = (0, types_js_1.prune)(checkExpr(c, e.right, op === "==" || op === "!=" ? l : undefined));
+    switch (op) {
+        case ".:":
+            for (const [t, x] of [[l, e.left], [r, e.right]]) {
+                if (t.k === "void") {
+                    c.error("CL3013", x.span, "this expression has no value to join");
+                }
+            }
+            return types_js_1.T.string;
+        case "..":
+            c.error("CL3072", e.opSpan, "'..' makes a slice range and only works inside `x[a .. b]`", ["join text with `.:`"]);
+            return types_js_1.T.unknown;
+        case "+":
+        case "-":
+        case "*":
+        case "/":
+        case "%":
+            return arithmetic(c, e, l, r);
+        case "==":
+        case "!=":
+            comparable(c, e, l, r);
+            return types_js_1.T.bool;
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+            if (((0, types_js_1.isNumeric)(l) && (0, types_js_1.isNumeric)(r)) || ((0, types_js_1.isStringLike)(l) && (0, types_js_1.isStringLike)(r)) || (0, types_js_1.isDynamic)(l) || (0, types_js_1.isDynamic)(r) || l.k === "param" || r.k === "param") {
+                return types_js_1.T.bool;
+            }
+            if (l.k === "option" || r.k === "option") {
+                c.strictError("CL3011", e.span, "comparing a value that may be null");
+                return types_js_1.T.bool;
+            }
+            c.error("CL3073", e.opSpan, `cannot order ${(0, types_js_1.typeToString)(l)} and ${(0, types_js_1.typeToString)(r)} with '${op}'`);
+            return types_js_1.T.bool;
+        case "&":
+        case "|":
+        case "^":
+        case "shl":
+        case "shr":
+            for (const [t, x] of [[l, e.left], [r, e.right]]) {
+                if (!(0, types_js_1.isIntLike)(t) && !(0, types_js_1.isDynamic)(t)) {
+                    c.error("CL3074", x.span, `'${op}' works on ints, got ${(0, types_js_1.typeToString)(t)}`);
+                }
+            }
+            return types_js_1.T.int;
+        default:
+            return types_js_1.T.unknown;
+    }
+}
+function narrowingsOf(c, e, truthy) {
+    return (0, flow_js_1.conditionNarrowings)(c, e, truthy);
+}
+function arithmetic(c, e, l, r) {
+    const op = e.op;
+    if ((0, types_js_1.isNumeric)(l) && (0, types_js_1.isNumeric)(r)) {
+        if ((0, types_js_1.isIntLike)(l) && (0, types_js_1.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 types_js_1.T.int;
+        }
+        return types_js_1.T.float;
+    }
+    if (l.k === "param" || r.k === "param") {
+        return l.k === "param" ? l : r;
+    }
+    if ((0, types_js_1.isDynamic)(l) || (0, types_js_1.isDynamic)(r)) {
+        if (l.k === "datatype" || r.k === "datatype") {
+            return l.k === "datatype" ? l : r;
+        }
+        return (0, types_js_1.isDynamic)(l) && (0, types_js_1.isDynamic)(r) ? types_js_1.T.any : types_js_1.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 ${(0, types_js_1.typeToString)(l)} and ${(0, types_js_1.typeToString)(r)}`);
+        return types_js_1.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 (0, types_js_1.prune)(fn.type.ret);
+        }
+    }
+    if (op === "+" && ((0, types_js_1.isStringLike)(l) || (0, types_js_1.isStringLike)(r))) {
+        c.error("CL3077", e.opSpan, "text is joined with `.:` in CL++, not `+`", [`"a" .: b`]);
+        return types_js_1.T.string;
+    }
+    if (l.k === "option" || r.k === "option") {
+        c.strictError("CL3011", e.span, `arithmetic on a value that may be null`);
+        return types_js_1.T.float;
+    }
+    c.error("CL3078", e.opSpan, `'${op}' needs numbers, got ${(0, types_js_1.typeToString)(l)} and ${(0, types_js_1.typeToString)(r)}`);
+    return types_js_1.T.unknown;
+}
+function comparable(c, e, l, r) {
+    if ((0, types_js_1.isDynamic)(l) || (0, types_js_1.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, `${(0, types_js_1.typeToString)(other)} is never null, so this is always ${e.op === "==" ? "false" : "true"}`);
+        }
+        return;
+    }
+    if ((0, typeops_js_1.assignable)(c, (0, checker_js_1.widenLiteral)(l), r) !== "no" || (0, typeops_js_1.assignable)(c, (0, checker_js_1.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 ((0, types_js_1.isNumeric)(l) && (0, types_js_1.isNumeric)(r)) {
+        return;
+    }
+    c.error("CL3044", e.span, `${(0, types_js_1.typeToString)(l)} and ${(0, types_js_1.typeToString)(r)} can never be equal`);
+}
+function isPlainValue(t) {
+    const p = (0, types_js_1.prune)(t);
+    return p.k === "int" || p.k === "float" || p.k === "bool" || p.k === "string" || p.k === "datatype" || p.k === "lit" || (0, types_js_1.isValueTable)(p);
+}
+function checkUpdate(c, e) {
+    const target = (0, members_js_1.checkAssignTarget)(c, e.target, true);
+    const t = (0, types_js_1.prune)(target.type);
+    if (!(0, types_js_1.isNumeric)(t) && !(0, types_js_1.isDynamic)(t)) {
+        c.error("CL3079", e.span, `'${e.delta > 0 ? "++" : "--"}' needs a number, got ${(0, types_js_1.typeToString)(t)}`);
+    }
+    const key = exprPathKey(e.target);
+    if (key) {
+        c.scope.invalidate(key);
+    }
+    e.target.ty = target.type;
+    return (0, checker_js_1.widenLiteral)(t);
+}
+function checkCast(c, e) {
+    const from = (0, types_js_1.prune)(checkExpr(c, e.operand));
+    const to = c.resolveType(e.type);
+    const target = (0, types_js_1.prune)(to);
+    if ((0, types_js_1.isDynamic)(from) || (0, types_js_1.isDynamic)(target)) {
+        return to;
+    }
+    const base = from.k === "option" ? (0, types_js_1.prune)(from.inner) : from;
+    if ((0, typeops_js_1.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 ((0, typeops_js_1.assignable)(c, base, target) === "ok") {
+        return to;
+    }
+    c.error("CL3080", e.span, `cannot convert ${(0, types_js_1.typeToString)(from)} to ${(0, types_js_1.typeToString)(target)}`, (0, types_js_1.isNumeric)(base) || (0, types_js_1.isNumeric)(target) ? ["convert numbers with int(x) / float(x) / string(x)"] : undefined);
+    return to;
+}
+function checkAwait(c, e) {
+    const t = (0, types_js_1.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 ? types_js_1.T.void : t.args.length === 1 ? t.args[0] : { k: "tuple", elems: t.args };
+    }
+    if (!(0, types_js_1.isDynamic)(t)) {
+        c.warn("CL3055", e.operand.span, `await on ${(0, types_js_1.typeToString)(t)} does nothing`, ["await a task, an async call or a Roblox event"]);
+    }
+    return t;
+}
+// ---------- functions as values ----------
+function checkFunctionExpr(c, e, expected) {
+    const exp = expected ? (0, types_js_1.prune)(expected) : null;
+    const expFn = exp && exp.k === "func" ? exp : exp && exp.k === "option" && (0, types_js_1.prune)(exp.inner).k === "func" ? (0, types_js_1.prune)(exp.inner) : null;
+    const outer = c.fn;
+    const declaredRet = e.returnType ? c.resolveType(e.returnType) : null;
+    const ctx = {
+        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, i) => {
+        let t;
+        if (p.type) {
+            t = c.resolveType(p.type);
+            const want = expFn?.params[i]?.type;
+            if (want && (0, typeops_js_1.assignable)(c, t, want) === "no" && !(0, types_js_1.isDynamic)(want)) {
+                c.error("CL3036", p.span, `parameter '${p.name}' is ${(0, types_js_1.typeToString)(t)}, but ${(0, types_js_1.typeToString)(want)} is passed here`);
+            }
+        }
+        else if (expFn && expFn.params[i]) {
+            t = expFn.params[i].type;
+        }
+        else if (p.variadic && expFn?.variadic) {
+            t = types_js_1.T.list(expFn.variadic);
+        }
+        else {
+            t = { k: "infer", resolved: null };
+        }
+        p.ty = p.variadic && !p.type && !expFn?.variadic ? types_js_1.T.list(types_js_1.T.any) : t;
+        return { name: p.name, type: t, optional: p.defaultValue !== null };
+    });
+    c.declareParams(e.params);
+    let ret;
+    if (Array.isArray(e.body)) {
+        for (const s of e.body) {
+            (0, statements_js_1.checkStatement)(c, s);
+        }
+        c.finishFunction(ctx, e.body, e.span, "function");
+        ret = declaredRet ?? (ctx.returns.length ? ctx.returns.reduce((a, b) => (0, typeops_js_1.join)(c, a, b)) : types_js_1.T.void);
+    }
+    else {
+        const t = checkExpr(c, e.body, expFn?.ret);
+        c.markCopy(e.body);
+        ret = declaredRet ?? (0, checker_js_1.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 types_js_1.T.func(params, ret);
+}