cluaupp 1.5.2 → 2.0.0-beta.2

package/generated/compiler/checker/statements.js

@@ -0,0 +1,792 @@
+"use strict";
+/** Statement checking. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumeric = void 0;
+exports.checkStatement = checkStatement;
+exports.checkHandler = checkHandler;
+const types_js_1 = require("../types.js");
+Object.defineProperty(exports, "isNumeric", { enumerable: true, get: function () { return types_js_1.isNumeric; } });
+const checker_js_1 = require("./checker.js");
+const exprs_js_1 = require("./exprs.js");
+const flow_js_1 = require("./flow.js");
+const members_js_1 = require("./members.js");
+const typeops_js_1 = require("./typeops.js");
+const yields_js_1 = require("./yields.js");
+function checkStatement(c, stmt) {
+    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 = (0, exprs_js_1.checkCondition)(c, stmt.cond);
+            void cond;
+            c.loopDepth++;
+            const scope = c.pushScope("loop");
+            (0, flow_js_1.applyNarrowings)(scope, (0, flow_js_1.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) {
+                (0, exprs_js_1.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", types_js_1.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 = (0, exprs_js_1.checkExpr)(c, stmt.value);
+            if ((0, types_js_1.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 = {
+                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 = (0, exprs_js_1.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, decl, sym) {
+    const outer = c.fn;
+    const ctx = { ...outer, decl, declaredRet: decl.returnType ? c.resolveType(decl.returnType) : null, returns: [], 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;
+    if (!decl.returnType && (0, types_js_1.prune)(fnType.ret).k === "infer") {
+        (0, types_js_1.prune)(fnType.ret).resolved = ctx.returns.length ? ctx.returns.reduce((a, b) => (sameish(a, b) ? a : types_js_1.T.any)) : types_js_1.T.void;
+    }
+    (decl.fn ||= {}).mayYield = ctx.yields;
+}
+function sameish(a, b) {
+    return (0, types_js_1.typeToString)(a) === (0, types_js_1.typeToString)(b);
+}
+// ---------- declarations ----------
+function checkVar(c, stmt) {
+    const predeclared = stmt.predeclared === true;
+    let declared = null;
+    if (stmt.declaredType) {
+        declared = c.resolveType(stmt.declaredType);
+    }
+    else if (stmt.decltypeOf) {
+        declared = (0, checker_js_1.widenLiteral)((0, exprs_js_1.checkExpr)(c, stmt.decltypeOf));
+    }
+    else if (stmt.declKind === "atomic") {
+        declared = types_js_1.T.int;
+    }
+    let initType = null;
+    if (stmt.init) {
+        initType = (0, exprs_js_1.checkExpr)(c, stmt.init, declared ?? undefined, stmt.unpack);
+        if ((0, types_js_1.prune)(initType).k === "void") {
+            c.error("CL3013", stmt.init.span, "this expression has no value");
+            initType = types_js_1.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 || ((0, types_js_1.prune)(declared).k !== "option" && (0, types_js_1.prune)(declared).k !== "any")) {
+        const name = stmt.names[0].name;
+        c.error("CL3014", stmt.span, `'${name}' needs an initial value`, declared && (0, types_js_1.prune)(declared).k === "instance" ? [`write \`${(0, types_js_1.typeToString)(declared)}? ${name} = null;\` for an Instance that starts empty`] : ["CL++ variables are always initialized: `let x = …;`"]);
+    }
+    if (stmt.declKind === "constexpr" && stmt.init && (0, checker_js_1.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 = (0, types_js_1.prune)(initType ?? types_js_1.T.unknown);
+        stmt.names.forEach((n, i) => {
+            let t = types_js_1.T.any;
+            if (src.k === "list") {
+                t = src.elem;
+            }
+            else if (src.k === "tuple") {
+                t = src.elems[i] ?? types_js_1.T.void;
+                if (i >= src.elems.length) {
+                    c.error("CL3016", n.span, `the value only has ${src.elems.length} element(s)`);
+                }
+            }
+            else if (!(0, types_js_1.isDynamic)(src)) {
+                c.error("CL3016", stmt.init?.span ?? stmt.span, `cannot destructure ${(0, types_js_1.typeToString)(src)}; expected a list`);
+            }
+            const sym = c.declare(n.name, "var", (0, checker_js_1.widenLiteral)(t), n.span, mutable);
+            n.sym = sym;
+        });
+        return;
+    }
+    const n = stmt.names[0];
+    let type = declared ?? (0, checker_js_1.widenLiteral)(initType ?? types_js_1.T.unknown);
+    if (stmt.declaredType && stmt.declaredType.kind === "Literal") {
+        type = declared;
+    }
+    if (predeclared && n.sym) {
+        const pre = n.sym;
+        if ((0, types_js_1.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 = (0, checker_js_1.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 && (0, types_js_1.prune)(initType).k !== "null" && (0, types_js_1.prune)(type).k === "option") {
+        // `Part? p = Part()` is known non-null until reassigned.
+        const key = `s${sym.id}`;
+        if ((0, types_js_1.prune)(initType).k !== "option") {
+            c.scope.narrowed.set(key, (0, types_js_1.nonNull)(type));
+        }
+    }
+}
+// ---------- assignment ----------
+function checkAssign(c, stmt) {
+    const target = (0, members_js_1.checkAssignTarget)(c, stmt.target, stmt.op !== "=");
+    const targetType = target.type;
+    let valueType = (0, exprs_js_1.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 = (0, types_js_1.prune)(targetType);
+        const vt = (0, types_js_1.prune)(valueType);
+        if ((0, types_js_1.isNumeric)(tt) && (0, types_js_1.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 ${(0, types_js_1.typeToString)(tt)} and ${(0, types_js_1.typeToString)(vt)}`);
+            }
+            else {
+                valueType = result;
+            }
+        }
+        else if (!(0, types_js_1.isDynamic)(tt) && !(0, types_js_1.isDynamic)(vt)) {
+            if (stmt.op === "+=" && (0, types_js_1.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 ${(0, types_js_1.typeToString)(tt)} and ${(0, types_js_1.typeToString)(vt)}`);
+            }
+        }
+    }
+    const key = (0, exprs_js_1.exprPathKey)(stmt.target);
+    if (key) {
+        c.scope.invalidate(key);
+        const vt = (0, types_js_1.prune)(valueType);
+        if (stmt.op === "=" && (0, types_js_1.prune)(targetType).k === "option" && vt.k !== "option" && vt.k !== "null" && !(0, types_js_1.isDynamic)(vt)) {
+            c.scope.narrowed.set(key, (0, types_js_1.nonNull)(targetType));
+        }
+    }
+}
+function describeTarget(e) {
+    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, stmt) {
+    const e = stmt.expr;
+    (0, exprs_js_1.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, stmt) {
+    if (stmt.letName) {
+        const t = (0, exprs_js_1.checkExpr)(c, stmt.cond);
+        const scope = c.pushScope("block");
+        const sym = c.declare(stmt.letName.name, "var", (0, checker_js_1.widenLiteral)((0, types_js_1.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;
+    }
+    (0, exprs_js_1.checkCondition)(c, stmt.cond);
+    const yes = (0, flow_js_1.conditionNarrowings)(c, stmt.cond, true);
+    const no = (0, flow_js_1.conditionNarrowings)(c, stmt.cond, false);
+    const thenScope = c.pushScope("block");
+    (0, flow_js_1.applyNarrowings)(thenScope, yes);
+    for (const s of stmt.then) {
+        checkStatement(c, s);
+    }
+    c.popScope();
+    if (stmt.else) {
+        const elseScope = c.pushScope("block");
+        (0, flow_js_1.applyNarrowings)(elseScope, no);
+        for (const s of stmt.else) {
+            checkStatement(c, s);
+        }
+        c.popScope();
+    }
+    const thenExits = (0, flow_js_1.alwaysExits)(c, stmt.then);
+    const elseExits = stmt.else ? (0, flow_js_1.alwaysExits)(c, stmt.else) : false;
+    if (thenExits && !elseExits) {
+        (0, flow_js_1.applyNarrowings)(c.scope, no);
+    }
+    else if (elseExits && !thenExits) {
+        (0, flow_js_1.applyNarrowings)(c.scope, yes);
+    }
+}
+function iterationOf(c, t, span) {
+    const p = (0, types_js_1.prune)(t);
+    switch (p.k) {
+        case "int":
+        case "lit":
+            if (typeof p.value === "string") {
+                return { kind: "string", elem: types_js_1.T.string };
+            }
+            return { kind: "range", elem: types_js_1.T.int };
+        case "float":
+            c.error("CL3018", span, "for … in over a number needs an int count", ["convert with int(...)"]);
+            return { kind: "range", elem: types_js_1.T.int };
+        case "string":
+            return { kind: "string", elem: types_js_1.T.string };
+        case "list":
+            return { kind: "list", elem: p.elem };
+        case "tuple":
+            return { kind: "list", elem: p.elems.reduce((a, b) => ((0, types_js_1.typeToString)(a) === (0, types_js_1.typeToString)(b) ? a : types_js_1.T.any), p.elems[0] ?? types_js_1.T.any) };
+        case "dict":
+            return { kind: "dict", elem: p.key };
+        case "table":
+            return { kind: "dict", elem: types_js_1.T.string };
+        case "option":
+            c.strictError("CL3011", span, `${(0, types_js_1.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: types_js_1.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: types_js_1.T.any };
+        default:
+            c.error("CL3018", span, `cannot iterate over ${(0, types_js_1.typeToString)(p)}`);
+            return { kind: "generic", elem: types_js_1.T.any };
+    }
+}
+function checkForIn(c, stmt) {
+    const it = (0, exprs_js_1.checkExpr)(c, stmt.iterable);
+    const { kind, elem } = iterationOf(c, it, stmt.iterable.span);
+    stmt.iterKind = kind;
+    let varType = (0, checker_js_1.widenLiteral)(elem);
+    if (stmt.declaredType) {
+        const declared = c.resolveType(stmt.declaredType);
+        const r = (0, typeops_js_1.assignable)(c, declared, elem);
+        const de = (0, types_js_1.prune)(declared);
+        const ee = (0, types_js_1.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, stmt) {
+    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) {
+            (0, exprs_js_1.checkExpr)(c, stmt.value);
+        }
+        return;
+    }
+    const expected = fn.declaredRet;
+    if (!stmt.value) {
+        if (expected && !(0, types_js_1.isDynamic)(expected) && (0, types_js_1.prune)(expected).k !== "void" && (0, types_js_1.prune)(expected).k !== "option") {
+            c.error("CL4006", stmt.span, `'${fn.decl?.name ?? "function"}' must return ${(0, types_js_1.typeToString)(expected)}`);
+        }
+        fn.returns.push(types_js_1.T.void);
+        return;
+    }
+    const t = (0, exprs_js_1.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 ((0, types_js_1.prune)(expected).k === "void" && (0, types_js_1.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, stmt) {
+    const subject = (0, exprs_js_1.checkExpr)(c, stmt.subject);
+    c.switchDepth++;
+    for (const k of stmt.cases) {
+        if (k.test) {
+            const t = (0, exprs_js_1.checkExpr)(c, k.test, subject);
+            if ((0, typeops_js_1.assignable)(c, (0, checker_js_1.widenLiteral)(subject), t) === "no" && (0, typeops_js_1.assignable)(c, (0, checker_js_1.widenLiteral)(t), subject) === "no") {
+                c.error("CL3019", k.test.span, `case ${(0, types_js_1.typeToString)(t)} can never match a ${(0, types_js_1.typeToString)(subject)}`);
+            }
+        }
+        c.pushScope("block");
+        for (const s of k.body) {
+            checkStatement(c, s);
+        }
+        c.popScope();
+    }
+    c.switchDepth--;
+}
+// ---------- match ----------
+function checkMatch(c, stmt) {
+    const subjectType = (0, exprs_js_1.checkExpr)(c, stmt.subject);
+    const subject = (0, types_js_1.prune)(subjectType);
+    const covered = new Set();
+    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) {
+            (0, exprs_js_1.checkCondition)(c, arm.guard);
+            (0, flow_js_1.applyNarrowings)(c.scope, (0, flow_js_1.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, subject) {
+    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, pattern, subject, covered) {
+    if (pattern.kind === "Wildcard") {
+        return null;
+    }
+    if (pattern.kind === "Value") {
+        const t = (0, exprs_js_1.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 ((0, typeops_js_1.assignable)(c, (0, checker_js_1.widenLiteral)(subject), t) === "no" && (0, typeops_js_1.assignable)(c, (0, checker_js_1.widenLiteral)(t), subject) === "no" && !(0, types_js_1.isDynamic)(subject)) {
+            c.error("CL3019", pattern.span, `pattern ${(0, types_js_1.typeToString)(t)} can never match a ${(0, types_js_1.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 (!(0, types_js_1.isDynamic)(subject)) {
+                    c.error("CL3032", pattern.span, `${name} only matches an Option, but the subject is ${(0, types_js_1.typeToString)(subject)}`);
+                }
+                pattern.res = { kind: "builtin", name };
+                return pattern.binding ? types_js_1.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, pattern, subject) {
+    if (pattern.binding) {
+        c.error("CL3033", pattern.span, `'${pattern.name}' is not a case of ${(0, types_js_1.typeToString)(subject)}`);
+        return types_js_1.T.unknown;
+    }
+    const 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 = (0, exprs_js_1.checkExpr)(c, expr, subject);
+    pattern.valueExpr = expr;
+    if ((0, typeops_js_1.assignable)(c, (0, checker_js_1.widenLiteral)(subject), t) === "no" && !(0, types_js_1.isDynamic)(t) && !(0, types_js_1.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 ${(0, types_js_1.typeToString)(subject)}`, info ? [`cases: ${info.cases.map((k) => k.name).join(", ")}`] : undefined);
+    }
+    return null;
+}
+// ---------- connections ----------
+function checkConnect(c, stmt) {
+    const signalType = (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, stmt.signal));
+    if (signalType.k === "clSignal") {
+        const sym = (0, exprs_js_1.rootSymbol)(stmt.signal);
+        const expected = signalType.params ? types_js_1.T.func(signalType.params.map((p, i) => ({ name: `arg${i + 1}`, type: p, optional: false })), types_js_1.T.void) : types_js_1.T.func([], types_js_1.T.void);
+        const handlerType = (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, stmt.handler, signalType.params ? expected : undefined));
+        if (handlerType.k !== "func" && !(0, types_js_1.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 = types_js_1.T.func(signalType.args.map((a, i) => ({ name: `arg${i + 1}`, type: a, optional: false })), types_js_1.T.void);
+        const handlerType = (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, stmt.handler, expected));
+        checkHandler(c, handlerType, signalType.args, stmt.handler.span);
+        stmt.target = "rbx";
+        return;
+    }
+    if (!(0, types_js_1.isDynamic)(signalType)) {
+        c.error("CL3034", stmt.signal.span, `'~>' connects a signal or a Roblox event, not ${(0, types_js_1.typeToString)(signalType)}`);
+    }
+    (0, exprs_js_1.checkExpr)(c, stmt.handler);
+    stmt.target = "rbx";
+}
+function checkHandler(c, handlerType, args, span) {
+    const h = (0, types_js_1.prune)(handlerType);
+    if (h.k !== "func") {
+        if (!(0, types_js_1.isDynamic)(h)) {
+            c.error("CL3034", span, `expected a function to handle the event, got ${(0, types_js_1.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) => (0, types_js_1.typeToString)(a)).join(", ")})`,
+        ]);
+        return;
+    }
+    h.params.forEach((p, i) => {
+        const arg = args[i];
+        if (!arg) {
+            return;
+        }
+        const pt = (0, types_js_1.prune)(p.type);
+        if (pt.k === "infer" && !pt.resolved) {
+            pt.resolved = arg;
+            return;
+        }
+        const r = (0, typeops_js_1.assignable)(c, p.type, arg);
+        if (r === "no") {
+            c.error("CL3036", span, `handler parameter '${p.name}' is ${(0, types_js_1.typeToString)(p.type)}, but the event passes ${(0, types_js_1.typeToString)(arg)}`);
+        }
+    });
+}
+// ---------- loops that never yield ----------
+function checkInfiniteLoop(c, stmt, forever, body) {
+    if (!forever || (0, flow_js_1.containsBreak)(body) || (0, flow_js_1.alwaysExits)(c, body) || containsReturn(body)) {
+        return;
+    }
+    if (!(0, yields_js_1.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) {
+    const visit = (s) => {
+        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) => a.body.some(visit));
+            case "Switch":
+                return s.cases.some((k) => k.body.some(visit));
+            default:
+                return false;
+        }
+    };
+    return body.some(visit);
+}