cluaupp 1.5.2 → 2.0.0-beta.1

package/generated/compiler/checker/calls.js

@@ -0,0 +1,999 @@
+"use strict";
+/**
+ * Calls: user functions (with call-site inference for unannotated parameters), methods, CL++
+ * builtins, struct/Instance/datatype construction, enum cases, Option/Result, `GetService`,
+ * generic class arguments (`WaitForChild<Model>("Map")`) and overload resolution on the Roblox API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonNull = void 0;
+exports.checkCall = checkCall;
+exports.checkNew = checkNew;
+exports.checkArgs = checkArgs;
+exports.joinTypes = joinTypes;
+const diagnostics_js_1 = require("../diagnostics.js");
+const types_js_1 = require("../types.js");
+Object.defineProperty(exports, "nonNull", { enumerable: true, get: function () { return types_js_1.nonNull; } });
+const checker_js_1 = require("./checker.js");
+const exprs_js_1 = require("./exprs.js");
+const members_js_1 = require("./members.js");
+const statements_js_1 = require("./statements.js");
+const typeops_js_1 = require("./typeops.js");
+/** Methods whose class-name string argument can be written as a type argument. */
+const CLASS_ARG_METHODS = new Set([
+    "FindFirstChildOfClass", "FindFirstChildWhichIsA", "FindFirstAncestorOfClass", "FindFirstAncestorWhichIsA",
+    "IsA", "GetService", "FindService",
+]);
+/** Methods whose result can be narrowed with a type argument (a checked downcast). */
+/** Axiom functions that return an int when every argument is an int (`Axiom.Clamp(hp - 5, 0, 100)`). */
+const INT_PRESERVING = new Set(["Clamp", "Min", "Max", "Abs", "Sign", "Floor", "Ceil", "Round", "Trunc", "Snap", "Wrap", "Pow", "Gcd", "Lcm", "Factorial", "Sum", "Approach"]);
+const CAST_RESULT_METHODS = new Set(["WaitForChild", "FindFirstChild", "FindFirstDescendant", "FindFirstAncestor", "Clone"]);
+function setCall(e, call, args, variadicArgs) {
+    e.res = { kind: "call", call, args, ...(variadicArgs && variadicArgs.length ? { variadicArgs } : {}) };
+}
+function checkCall(c, e, expected) {
+    const callee = e.callee;
+    if (e.legacyConnect) {
+        c.warn("CL1204", callee.span, "`event~>Connect(fn)` is Cluaupp 1.x syntax", ["write `event.Connect(fn)` or the statement `event ~> fn;`"]);
+    }
+    if (callee.kind === "Name" && !c.scope.lookup(callee.name)) {
+        const special = checkSpecialName(c, e, callee, expected);
+        if (special) {
+            return special;
+        }
+    }
+    if (callee.kind === "Name") {
+        const sym = c.scope.lookup(callee.name);
+        if (sym && sym.kind === "struct" && sym.typeId) {
+            sym.used = true;
+            callee.res = { kind: "struct", name: sym.name, sym };
+            return constructStruct(c, e, sym.typeId, callee.typeArgs, e.args, expected);
+        }
+        if (sym && sym.kind === "signal") {
+            return fireSignal(c, e, sym);
+        }
+        if (sym && sym.kind === "variant") {
+            sym.used = true;
+            callee.res = { kind: "builtin", name: "variant" };
+            const fn = sym.type;
+            const r = checkArgs(c, e, fn, callee.span, null);
+            setCall(e, { form: "variant" }, r.args);
+            return fn.ret;
+        }
+    }
+    if (callee.kind === "SelfField") {
+        const t = (0, exprs_js_1.checkExpr)(c, callee);
+        if (callee.res?.kind === "method") {
+            return finishCall(c, e, (0, types_js_1.prune)(t), callee.span, { form: "call" }, expected);
+        }
+        return finishCall(c, e, (0, types_js_1.prune)(t), callee.span, { form: "call" }, expected);
+    }
+    if (callee.kind === "Member") {
+        return checkMemberCall(c, e, callee, expected);
+    }
+    const t = (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, callee));
+    if (t.k === "namespace" && t.ns.kind === "struct") {
+        return constructStruct(c, e, t.ns.id, null, e.args, expected);
+    }
+    if (t.k === "namespace" && t.ns.kind === "datatype") {
+        return constructDatatype(c, e, t.ns.name, e.args);
+    }
+    return finishCall(c, e, t, callee.span, { form: "call" }, expected);
+}
+// ---------- names with special meaning ----------
+function checkSpecialName(c, e, callee, expected) {
+    const name = callee.name;
+    switch (name) {
+        case "len":
+        case "list":
+        case "array":
+        case "dictionary":
+        case "push":
+        case "pop":
+        case "insert":
+        case "remove":
+        case "find":
+        case "sort":
+        case "args":
+        case "mutex":
+        case "lock":
+        case "unlock":
+        case "fetch_add":
+        case "atomic_load":
+        case "actor":
+        case "Some":
+        case "Ok":
+        case "Err":
+        case "int":
+        case "float":
+        case "bool":
+        case "string":
+        case "GetService":
+            callee.res = { kind: "builtin", name };
+            callee.ty = types_js_1.T.any;
+            return checkBuiltin(c, e, name, callee.typeArgs, expected);
+        case "type":
+            c.requireRoblox(callee.span, "type");
+            callee.res = { kind: "global", luau: "type" };
+            callee.ty = types_js_1.T.any;
+            checkArgsLoose(c, e);
+            setCall(e, { form: "call" }, e.args.map((a) => a.value));
+            return types_js_1.T.string;
+        default:
+            break;
+    }
+    if (name === "Vector2" || name === "Vector3" || (c.api.hasDatatype(name) && !c.api.hasClass(name))) {
+        callee.res = { kind: "global", luau: name };
+        return constructDatatype(c, e, name, e.args);
+    }
+    if (name === "Vector4") {
+        c.error("RBX5002", callee.span, "Vector4 has no Roblox equivalent", ["use Color3 for colors or a struct"]);
+        checkArgsLoose(c, e);
+        return types_js_1.T.unknown;
+    }
+    if (c.api.hasClass(name) && !c.api.isService(name)) {
+        c.requireRoblox(callee.span, name);
+        callee.res = { kind: "global", luau: name };
+        return constructInstance(c, e, name, e.args, callee.span);
+    }
+    return null;
+}
+// ---------- builtins ----------
+function argValue(e, i) {
+    return e.args[i]?.value ?? null;
+}
+function arity(c, e, name, min, max = min) {
+    if (e.args.some((a) => a.name !== null) && name !== "dictionary") {
+        c.error("CL3101", e.span, `${name}(…) does not take named arguments`);
+    }
+    if (e.args.length < min || e.args.length > max) {
+        c.error("CL3102", e.span, `${name} takes ${min === max ? min : `${min} to ${max}`} argument${max === 1 ? "" : "s"}, got ${e.args.length}`);
+        return false;
+    }
+    return true;
+}
+function checkArgsLoose(c, e) {
+    return e.args.map((a) => (0, exprs_js_1.checkExpr)(c, a.value));
+}
+function listOf(c, x, what) {
+    if (!x) {
+        return null;
+    }
+    const t = (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, x));
+    if (t.k === "list") {
+        return t;
+    }
+    if (!(0, types_js_1.isDynamic)(t)) {
+        c.error("CL3103", x.span, `${what} needs a list, got ${(0, types_js_1.typeToString)(t)}`);
+    }
+    return null;
+}
+function requireMutableList(c, x, what) {
+    if (!x) {
+        return;
+    }
+    const root = (0, exprs_js_1.rootSymbol)(x);
+    if (root && (root.kind === "var" || root.kind === "param") && !root.mutable) {
+        c.diags.error("CL2040", x.span, `${what} changes '${root.name}', which is declared with let`, ["declare it with `let mut`"], {
+            span: root.span,
+            text: `mut ${root.name}`,
+            title: `Make '${root.name}' mutable (let mut)`,
+        });
+    }
+    if (root) {
+        root.mutatedFields = true;
+    }
+}
+function elementSlot(list, value) {
+    const elem = (0, types_js_1.prune)(list.elem);
+    if (elem.k === "infer" && !elem.resolved) {
+        elem.resolved = (0, checker_js_1.widenLiteral)(value);
+        return elem.resolved;
+    }
+    return list.elem;
+}
+function checkBuiltin(c, e, name, typeArgs, expected) {
+    const builtin = (elemType) => setCall(e, { form: "builtin", name, ...(elemType ? { elemType } : {}) }, e.args.map((a) => a.value));
+    switch (name) {
+        case "len": {
+            arity(c, e, "len", 1);
+            const x = argValue(e, 0);
+            const t = x ? (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, x)) : types_js_1.T.unknown;
+            if (!(t.k === "list" || t.k === "string" || t.k === "lit" || t.k === "dict" || t.k === "buffer" || t.k === "table" || (0, types_js_1.isDynamic)(t))) {
+                c.error("CL3104", x?.span ?? e.span, `len(…) needs a list, text or dictionary, got ${(0, types_js_1.typeToString)(t)}`, t.k === "instance" ? ["for children use len(x.GetChildren())"] : undefined);
+            }
+            builtin(t);
+            return types_js_1.T.int;
+        }
+        case "list": {
+            const ex = expected ? (0, types_js_1.prune)(expected) : null;
+            if (e.args.length === 0) {
+                builtin();
+                return ex && ex.k === "list" ? ex : types_js_1.T.list({ k: "infer", resolved: null });
+            }
+            const want = ex && ex.k === "list" ? ex.elem : undefined;
+            let elem = types_js_1.T.never;
+            for (const a of e.args) {
+                if (a.name) {
+                    c.error("CL3101", a.nameSpan ?? a.value.span, "list(…) takes values, not named arguments", ["use dictionary(Key: value, …) for named entries"]);
+                }
+                const t = (0, exprs_js_1.checkExpr)(c, a.value, want);
+                c.markCopy(a.value);
+                elem = (0, typeops_js_1.join)(c, elem, (0, checker_js_1.widenLiteral)(t));
+            }
+            builtin();
+            if (want) {
+                for (const a of e.args) {
+                    c.expectAssignable(want, a.value.ty ?? types_js_1.T.unknown, a.value.span, "list element");
+                }
+                return ex;
+            }
+            return types_js_1.T.list((0, types_js_1.prune)(elem).k === "never" ? types_js_1.T.any : elem);
+        }
+        case "array": {
+            if (!typeArgs || typeArgs.length !== 1) {
+                c.error("CL3105", e.span, "array needs its element type: array<int>(1, 2, 3)");
+                checkArgsLoose(c, e);
+                builtin();
+                return types_js_1.T.list(types_js_1.T.unknown);
+            }
+            const elem = c.resolveType(typeArgs[0]);
+            for (const a of e.args) {
+                const t = (0, exprs_js_1.checkExpr)(c, a.value, elem);
+                c.expectAssignable(elem, t, a.value.span, "array element");
+                c.markCopy(a.value);
+            }
+            builtin(elem);
+            return types_js_1.T.list(elem);
+        }
+        case "dictionary": {
+            if (e.args.length && e.args.every((a) => a.name !== null)) {
+                // dictionary(Transparency: 1, Color: c) → { Transparency = 1, Color = c }
+                const fields = {};
+                for (const a of e.args) {
+                    fields[a.name] = (0, checker_js_1.widenLiteral)((0, exprs_js_1.checkExpr)(c, a.value));
+                    c.markCopy(a.value);
+                }
+                setCall(e, { form: "table", keys: e.args.map((a) => a.name) }, e.args.map((a) => a.value));
+                return { k: "table", fields };
+            }
+            let key = types_js_1.T.any;
+            let value = types_js_1.T.any;
+            if (typeArgs && typeArgs.length === 2) {
+                key = c.resolveType(typeArgs[0]);
+                value = c.resolveType(typeArgs[1]);
+            }
+            else if (typeArgs) {
+                c.error("CL3105", e.span, "dictionary takes two type arguments: dictionary<string, int>(…)");
+            }
+            else if (expected && (0, types_js_1.prune)(expected).k === "dict") {
+                const ex = (0, types_js_1.prune)(expected);
+                key = ex.key;
+                value = ex.value;
+            }
+            else if (e.args.length === 0) {
+                key = { k: "infer", resolved: null };
+                value = { k: "infer", resolved: null };
+            }
+            if (e.args.length % 2 !== 0) {
+                c.error("CL3106", e.span, "dictionary(…) takes key/value pairs: dictionary<string, int>(\"a\", 1, \"b\", 2)");
+            }
+            let inferredKey = types_js_1.T.never;
+            let inferredValue = types_js_1.T.never;
+            e.args.forEach((a, i) => {
+                const isKey = i % 2 === 0;
+                const want = isKey ? key : value;
+                const t = (0, exprs_js_1.checkExpr)(c, a.value, (0, types_js_1.isDynamic)(want) ? undefined : want);
+                c.markCopy(a.value);
+                if (!(0, types_js_1.isDynamic)(want)) {
+                    c.expectAssignable(want, t, a.value.span, isKey ? "dictionary key" : "dictionary value");
+                }
+                else if (isKey) {
+                    inferredKey = (0, typeops_js_1.join)(c, inferredKey, (0, checker_js_1.widenLiteral)(t));
+                }
+                else {
+                    inferredValue = (0, typeops_js_1.join)(c, inferredValue, (0, checker_js_1.widenLiteral)(t));
+                }
+            });
+            builtin();
+            if (!typeArgs && e.args.length && (0, types_js_1.isDynamic)(key)) {
+                return types_js_1.T.dict((0, types_js_1.prune)(inferredKey).k === "never" ? types_js_1.T.any : inferredKey, (0, types_js_1.prune)(inferredValue).k === "never" ? types_js_1.T.any : inferredValue);
+            }
+            return types_js_1.T.dict(key, value);
+        }
+        case "push": {
+            arity(c, e, "push", 2);
+            const list = listOf(c, argValue(e, 0), "push");
+            requireMutableList(c, argValue(e, 0), "push");
+            const v = argValue(e, 1);
+            if (v) {
+                const want = list ? elementSlot(list, (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, v, list.typed && !(0, types_js_1.isDynamic)(list.elem) ? list.elem : undefined))) : types_js_1.T.any;
+                if (list && list.typed) {
+                    c.expectAssignable(want, v.ty ?? types_js_1.T.unknown, v.span, "push");
+                }
+                c.markCopy(v);
+            }
+            builtin();
+            return types_js_1.T.void;
+        }
+        case "pop": {
+            arity(c, e, "pop", 1);
+            const list = listOf(c, argValue(e, 0), "pop");
+            requireMutableList(c, argValue(e, 0), "pop");
+            builtin();
+            return list ? list.elem : types_js_1.T.any;
+        }
+        case "insert": {
+            arity(c, e, "insert", 3);
+            const list = listOf(c, argValue(e, 0), "insert");
+            requireMutableList(c, argValue(e, 0), "insert");
+            const i = argValue(e, 1);
+            if (i) {
+                const it = (0, exprs_js_1.checkExpr)(c, i);
+                if (!(0, types_js_1.isIntLike)(it) && !(0, types_js_1.isDynamic)(it)) {
+                    c.error("CL3060", i.span, `insert position must be int, got ${(0, types_js_1.typeToString)(it)}`);
+                }
+            }
+            const v = argValue(e, 2);
+            if (v) {
+                const vt = (0, exprs_js_1.checkExpr)(c, v, list?.elem);
+                if (list) {
+                    c.expectAssignable(elementSlot(list, vt), vt, v.span, "insert");
+                }
+                c.markCopy(v);
+            }
+            builtin();
+            return types_js_1.T.void;
+        }
+        case "remove": {
+            arity(c, e, "remove", 2);
+            const target = argValue(e, 0);
+            const t = target ? (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, target)) : types_js_1.T.unknown;
+            requireMutableList(c, target, "remove");
+            const k = argValue(e, 1);
+            const kt = k ? (0, exprs_js_1.checkExpr)(c, k) : types_js_1.T.unknown;
+            if (t.k === "list") {
+                if (!(0, types_js_1.isIntLike)(kt) && !(0, types_js_1.isDynamic)(kt)) {
+                    c.error("CL3060", k.span, `remove position must be int, got ${(0, types_js_1.typeToString)(kt)}`);
+                }
+                builtin(types_js_1.T.list(types_js_1.T.any));
+                return t.elem;
+            }
+            if (t.k === "dict") {
+                if ((0, typeops_js_1.assignable)(c, t.key, kt) === "no") {
+                    c.error("CL3063", k.span, `dictionary key must be ${(0, types_js_1.typeToString)(t.key)}`);
+                }
+                builtin(types_js_1.T.dict(types_js_1.T.any, types_js_1.T.any));
+                return t.value;
+            }
+            if (!(0, types_js_1.isDynamic)(t)) {
+                c.error("CL3103", target?.span ?? e.span, `remove needs a list or dictionary, got ${(0, types_js_1.typeToString)(t)}`);
+            }
+            builtin();
+            return types_js_1.T.any;
+        }
+        case "find": {
+            arity(c, e, "find", 2);
+            const list = listOf(c, argValue(e, 0), "find");
+            const v = argValue(e, 1);
+            if (v) {
+                const vt = (0, exprs_js_1.checkExpr)(c, v, list?.elem);
+                if (list && (0, typeops_js_1.assignable)(c, list.elem, vt) === "no" && (0, typeops_js_1.assignable)(c, vt, list.elem) === "no") {
+                    c.error("CL3107", v.span, `find looks for ${(0, types_js_1.typeToString)(list.elem)}, got ${(0, types_js_1.typeToString)(vt)}`);
+                }
+            }
+            builtin(list?.elem);
+            return types_js_1.T.int;
+        }
+        case "sort": {
+            arity(c, e, "sort", 1);
+            const list = listOf(c, argValue(e, 0), "sort");
+            if (list && !(0, types_js_1.isNumeric)(list.elem) && !(0, types_js_1.isStringLike)(list.elem) && !(0, types_js_1.isDynamic)(list.elem)) {
+                c.error("CL3108", e.span, `sort orders numbers or text, not ${(0, types_js_1.typeToString)(list.elem)}`);
+            }
+            builtin();
+            return list ?? types_js_1.T.list(types_js_1.T.any);
+        }
+        case "args":
+            c.error("RBX5100", e.span, "args() has no meaning on Roblox: scripts get no command line");
+            builtin();
+            return types_js_1.T.list(types_js_1.T.string);
+        case "actor":
+            c.error("RBX5100", e.span, "actor(...) is the clpp VM sandbox; on Roblox use an Actor instance with parallel Luau");
+            checkArgsLoose(c, e);
+            builtin();
+            return types_js_1.T.any;
+        case "mutex":
+            arity(c, e, "mutex", 0);
+            builtin();
+            return types_js_1.T.datatype("__Mutex");
+        case "lock":
+        case "unlock": {
+            arity(c, e, name, 1);
+            checkArgsLoose(c, e);
+            if (name === "lock") {
+                c.noteYield();
+            }
+            builtin();
+            return types_js_1.T.void;
+        }
+        case "fetch_add":
+        case "atomic_load": {
+            arity(c, e, name, name === "fetch_add" ? 2 : 1);
+            const a = argValue(e, 0);
+            if (a) {
+                (0, exprs_js_1.checkExpr)(c, a);
+                const sym = a.kind === "Name" ? c.scope.lookup(a.name) : undefined;
+                if (!sym || !sym.atomic) {
+                    c.error("CL3109", a.span, `${name} needs a variable declared with \`atomic\``);
+                }
+            }
+            if (name === "fetch_add" && argValue(e, 1)) {
+                (0, exprs_js_1.checkExpr)(c, argValue(e, 1));
+            }
+            builtin();
+            return types_js_1.T.int;
+        }
+        case "Some": {
+            arity(c, e, "Some", 1);
+            const ex = expected ? (0, types_js_1.prune)(expected) : null;
+            const inner = ex && ex.k === "option" ? ex.inner : undefined;
+            const t = argValue(e, 0) ? (0, exprs_js_1.checkExpr)(c, argValue(e, 0), inner) : types_js_1.T.unknown;
+            if ((0, types_js_1.prune)(t).k === "option" || (0, types_js_1.prune)(t).k === "null") {
+                c.error("CL3110", e.span, "Some(…) of a value that may already be null cannot be told apart from None on Roblox");
+            }
+            if (argValue(e, 0)) {
+                c.markCopy(argValue(e, 0));
+            }
+            setCall(e, { form: "some" }, e.args.map((a) => a.value));
+            return types_js_1.T.option(inner ?? (0, checker_js_1.widenLiteral)(t));
+        }
+        case "Ok":
+        case "Err": {
+            arity(c, e, name, 1);
+            const ex = expected ? (0, types_js_1.prune)(expected) : null;
+            const res = ex && ex.k === "result" ? ex : null;
+            const want = res ? (name === "Ok" ? res.ok : res.err) : undefined;
+            const t = argValue(e, 0) ? (0, checker_js_1.widenLiteral)((0, exprs_js_1.checkExpr)(c, argValue(e, 0), want)) : types_js_1.T.unknown;
+            if (argValue(e, 0)) {
+                c.markCopy(argValue(e, 0));
+            }
+            setCall(e, { form: name === "Ok" ? "ok" : "err" }, e.args.map((a) => a.value));
+            return name === "Ok" ? { k: "result", ok: res?.ok ?? t, err: res?.err ?? types_js_1.T.any } : { k: "result", ok: res?.ok ?? types_js_1.T.any, err: res?.err ?? t };
+        }
+        case "int":
+        case "float":
+        case "bool":
+        case "string": {
+            arity(c, e, name, 1);
+            const x = argValue(e, 0);
+            const t = x ? (0, types_js_1.prune)((0, exprs_js_1.checkExpr)(c, x)) : types_js_1.T.unknown;
+            if ((name === "int" || name === "float") && !(0, types_js_1.isNumeric)(t) && !(0, types_js_1.isStringLike)(t) && !(0, types_js_1.isDynamic)(t) && t.k !== "enum" && t.k !== "rbxEnumItem") {
+                c.error("CL3111", x?.span ?? e.span, `cannot convert ${(0, types_js_1.typeToString)(t)} to ${name}`);
+            }
+            if ((name === "int" || name === "float") && (0, types_js_1.isStringLike)(t)) {
+                c.warn("CL3112", x.span, `${name}(text) is null-free on Roblox only if the text is a number`, ["prefer Text.toNumber(text), which reports bad input"]);
+            }
+            setCall(e, { form: "convert", to: name }, [x]);
+            return name === "int" ? types_js_1.T.int : name === "float" ? types_js_1.T.float : name === "bool" ? types_js_1.T.bool : types_js_1.T.string;
+        }
+        case "GetService": {
+            let service = null;
+            if (typeArgs && typeArgs.length === 1 && typeArgs[0].kind === "Named") {
+                service = typeArgs[0].name;
+            }
+            else if (e.args.length === 1 && e.args[0].value.kind === "String") {
+                service = e.args[0].value.value;
+            }
+            if (!service) {
+                c.error("RBX5050", e.span, "GetService needs the service name: GetService<Players>() or GetService(\"Players\")");
+                return types_js_1.T.unknown;
+            }
+            return serviceCall(c, e, service, e.span);
+        }
+        default:
+            return types_js_1.T.unknown;
+    }
+}
+function serviceCall(c, e, service, span) {
+    if (!c.api.isService(service)) {
+        const s = (0, diagnostics_js_1.suggest)(service, c.api.services);
+        c.error("RBX5051", span, `'${service}' is not a Roblox service`, s ? [`did you mean ${s}?`] : undefined);
+        return types_js_1.T.unknown;
+    }
+    c.useService(service, span);
+    setCall(e, { form: "service", service }, []);
+    const dm = c.input.dataModel?.children.get(service);
+    return { k: "instance", cls: service, ...(dm ? { dm } : {}) };
+}
+// ---------- member calls ----------
+function checkMemberCall(c, e, callee, expected) {
+    const t = (0, types_js_1.prune)((0, members_js_1.checkMember)(c, callee, undefined, { forCall: true }));
+    const res = callee.res;
+    if (!res) {
+        return finishCall(c, e, t, callee.span, { form: "call" }, expected);
+    }
+    switch (res.kind) {
+        case "enumCase":
+            if (res.hasPayload) {
+                const fn = t;
+                const r = checkArgs(c, e, fn, callee.span, null);
+                setCall(e, { form: "enumCase", enumId: res.enumName, index: res.index }, r.args);
+                return fn.ret;
+            }
+            c.error("CL3113", e.span, `this enum case carries no value; write it without parentheses`);
+            return t;
+        case "moduleMember":
+            if (res.memberKind === "struct" && t.k === "namespace" && t.ns.kind === "struct") {
+                return constructStruct(c, e, t.ns.id, callee.typeArgs, e.args, expected);
+            }
+            break;
+        case "builtin":
+            if (res.name === "OnChange") {
+                const fn = t;
+                const r = checkArgs(c, e, fn, callee.span, null);
+                const sym = c.scope.lookup(callee.object.name);
+                (sym.handlers ||= []).push(...r.args.filter(Boolean));
+                setCall(e, { form: "observe", sym }, r.args);
+                return types_js_1.T.void;
+            }
+            break;
+        case "stdlib": {
+            const fn = t;
+            const r = checkArgs(c, e, fn, callee.span, null);
+            setCall(e, { form: "std", module: res.module, fn: res.member }, r.args);
+            if (res.module === "axiom" && INT_PRESERVING.has(res.member) && r.args.length && r.args.every((a) => a && (0, types_js_1.isIntLike)(a.ty ?? types_js_1.T.any))) {
+                return types_js_1.T.int;
+            }
+            return fn.ret;
+        }
+        case "library":
+            if (res.stringMethod) {
+                const r = checkArgs(c, e, t, callee.span, null);
+                setCall(e, { form: "stringMethod", name: callee.name }, r.args, r.rest);
+                return (0, types_js_1.prune)(t.ret);
+            }
+            break;
+        case "datatypeStatic":
+            if (res.datatype === "Instance" && res.member === "new") {
+                return instanceNewCall(c, e, callee);
+            }
+            break;
+        case "rbxMethod":
+            if (callee.name === "GetService" && (callee.typeArgs || e.args[0]?.value.kind === "String")) {
+                const name = callee.typeArgs?.[0]?.kind === "Named" ? callee.typeArgs[0].name : e.args[0]?.value.kind === "String" ? e.args[0].value.value : null;
+                if (name) {
+                    return serviceCall(c, e, name, e.span);
+                }
+            }
+            if (callee.typeArgs && callee.typeArgs.length) {
+                return genericRobloxCall(c, e, callee, t, expected);
+            }
+            if (CLASS_ARG_METHODS.has(callee.name) && e.args[0]?.value.kind === "String") {
+                const cls = e.args[0].value.value;
+                if (!c.api.hasClass(cls)) {
+                    const s = (0, diagnostics_js_1.suggest)(cls, Object.keys(c.api.classes));
+                    c.error("RBX5052", e.args[0].value.span, `'${cls}' is not a Roblox class`, s ? [`did you mean "${s}"?`] : undefined);
+                }
+                const r = checkArgs(c, e, t, callee.span, null);
+                setCall(e, { form: "call" }, r.args, r.rest);
+                const ret = (0, types_js_1.prune)(t.ret);
+                if (c.api.hasClass(cls) && callee.name !== "IsA") {
+                    return ret.k === "option" ? types_js_1.T.option(types_js_1.T.instance(cls)) : types_js_1.T.instance(cls);
+                }
+                return ret;
+            }
+            break;
+        case "datatypeMember":
+            if (res.datatype === "RBXScriptSignal" && (callee.name === "Connect" || callee.name === "Once" || callee.name === "ConnectParallel")) {
+                const signal = (0, types_js_1.prune)(callee.object.ty ?? types_js_1.T.any);
+                const r = checkArgs(c, e, t, callee.span, null);
+                if (signal.k === "rbxSignal" && r.args[0]) {
+                    handlerCheck(c, r.args[0], signal.args);
+                }
+                setCall(e, { form: "call" }, r.args);
+                return types_js_1.T.datatype("RBXScriptConnection");
+            }
+            break;
+        default:
+            break;
+    }
+    if (t.k === "namespace" && t.ns.kind === "struct") {
+        return constructStruct(c, e, t.ns.id, callee.typeArgs, e.args, expected);
+    }
+    if (t.k === "namespace" && t.ns.kind === "datatype") {
+        return constructDatatype(c, e, t.ns.name, e.args);
+    }
+    return finishCall(c, e, t, callee.span, { form: "call" }, expected, callee.typeArgs);
+}
+function handlerCheck(c, handler, args) {
+    (0, statements_js_1.checkHandler)(c, handler.ty ?? types_js_1.T.any, args, handler.span);
+}
+/** `x.WaitForChild<Model>("Map")`, `x.FindFirstChildOfClass<Humanoid>()`, `x.IsA<BasePart>()`. */
+function genericRobloxCall(c, e, callee, fn, expected) {
+    const node = callee.typeArgs[0];
+    const target = c.resolveType(node);
+    const p = (0, types_js_1.prune)(target);
+    if (p.k !== "instance") {
+        c.error("RBX5053", node.span, `${callee.name}<…> needs a Roblox class, got ${(0, types_js_1.typeToString)(target)}`);
+        const r = checkArgs(c, e, fn, callee.span, null);
+        setCall(e, { form: "call" }, r.args, r.rest);
+        return fn.ret;
+    }
+    if (CLASS_ARG_METHODS.has(callee.name)) {
+        const shifted = { ...fn, params: fn.params.slice(1) };
+        const r = checkArgs(c, e, shifted, callee.span, null);
+        setCall(e, { form: "classArg", cls: p.cls, cast: callee.name !== "IsA" }, r.args, r.rest);
+        const ret = (0, types_js_1.prune)(fn.ret);
+        if (callee.name === "IsA") {
+            return types_js_1.T.bool;
+        }
+        return ret.k === "option" ? types_js_1.T.option(p) : p;
+    }
+    if (CAST_RESULT_METHODS.has(callee.name)) {
+        const r = checkArgs(c, e, fn, callee.span, null);
+        setCall(e, { form: "cast", to: p }, r.args, r.rest);
+        const ret = (0, types_js_1.prune)(fn.ret);
+        return ret.k === "option" ? types_js_1.T.option(p) : p;
+    }
+    c.error("RBX5054", node.span, `${callee.name} does not take a type argument`, [
+        `type arguments work on ${[...CLASS_ARG_METHODS, ...CAST_RESULT_METHODS].join(", ")}`,
+    ]);
+    void expected;
+    return finishCall(c, e, fn, callee.span, { form: "call" }, undefined);
+}
+function instanceNewCall(c, e, callee) {
+    const first = e.args[0]?.value;
+    checkArgsLoose(c, e);
+    setCall(e, { form: "call" }, e.args.map((a) => a.value));
+    if (!first || first.kind !== "String") {
+        if (first && !(0, types_js_1.isStringLike)(first.ty ?? types_js_1.T.any) && !(0, types_js_1.isDynamic)(first.ty ?? types_js_1.T.any)) {
+            c.error("RBX5055", first.span, "Instance.new needs a class name");
+        }
+        return types_js_1.T.instance("Instance");
+    }
+    const cls = first.value;
+    const problem = c.api.creationError(cls);
+    if (problem) {
+        const s = c.api.hasClass(cls) ? null : (0, diagnostics_js_1.suggest)(cls, Object.keys(c.api.classes));
+        c.error("RBX5056", first.span, problem, s ? [`did you mean "${s}"?`] : undefined);
+        return types_js_1.T.unknown;
+    }
+    if (e.args.length > 1) {
+        c.warn("PERF8001", e.args[1].value.span, "Instance.new with a parent sets Parent before the other properties (slow replication)", [
+            `create it first and set Parent last, or write ${cls}(Name: …, Parent: …)`,
+        ]);
+    }
+    if (c.api.classes[cls].deprecated) {
+        c.warn("RBX5010", first.span, `${cls} is deprecated`);
+    }
+    void callee;
+    return types_js_1.T.instance(cls);
+}
+// ---------- construction ----------
+function checkNew(c, e, expected) {
+    const target = e.target;
+    const asCall = { kind: "Call", callee: target, args: e.args, span: e.span };
+    let t;
+    if (target.kind === "Name" && !c.scope.lookup(target.name) && c.api.hasClass(target.name)) {
+        c.requireRoblox(target.span, target.name);
+        target.res = { kind: "global", luau: target.name };
+        t = constructInstance(c, asCall, target.name, e.args, target.span);
+    }
+    else {
+        t = checkCall(c, asCall, expected);
+        const form = asCall.res?.kind === "call" ? asCall.res.call.form : "call";
+        if (form !== "struct" && form !== "instance" && form !== "datatype") {
+            c.error("CL3114", e.span, "`new` builds a struct, a Roblox Instance or a datatype");
+        }
+    }
+    e.res = asCall.res;
+    return t;
+}
+function constructStruct(c, e, id, typeArgs, args, expected) {
+    const info = c.structs.get(id);
+    if (!info) {
+        checkArgsLoose(c, e);
+        return types_js_1.T.unknown;
+    }
+    c.resolveStruct(info, new Set());
+    if (info.isAbstract) {
+        c.error("CL3115", e.span, `abstract type ${info.name} cannot be constructed`, ["construct one of the structs that inherit from it"]);
+    }
+    const bindings = new Map();
+    if (typeArgs && typeArgs.length) {
+        if (typeArgs.length !== info.typeParams.length) {
+            c.error("CL3001", e.span, `${info.name} takes ${info.typeParams.length} type argument(s)`);
+        }
+        info.typeParams.forEach((p, i) => typeArgs[i] && bindings.set(p, c.resolveType(typeArgs[i])));
+    }
+    else if (expected && (0, types_js_1.prune)(expected).k === "struct" && (0, types_js_1.prune)(expected).id === id) {
+        const ex = (0, types_js_1.prune)(expected);
+        info.typeParams.forEach((p, i) => ex.args[i] && (0, types_js_1.prune)(ex.args[i]).k !== "param" && bindings.set(p, ex.args[i]));
+    }
+    const params = info.fields.map((f) => ({ name: f.name, type: f.type, optional: f.defaultValue !== null }));
+    const fn = { k: "func", params, ret: types_js_1.T.void, variadic: null };
+    const r = checkArgs(c, e, fn, e.callee.span, null, bindings);
+    setCall(e, { form: "struct", id }, r.args);
+    const args2 = info.typeParams.map((p) => bindings.get(p) ?? { k: "param", name: p });
+    void args;
+    return { k: "struct", id, name: info.name, args: info.typeParams.length ? args2 : [] };
+}
+function constructInstance(c, e, cls, args, span) {
+    const problem = c.api.creationError(cls);
+    if (problem) {
+        c.error("RBX5056", span, problem);
+    }
+    if (c.api.classes[cls]?.deprecated) {
+        c.warn("RBX5010", span, `${cls} is deprecated`);
+    }
+    const props = [];
+    let parent = null;
+    for (const a of args) {
+        if (a.name === null) {
+            if (parent) {
+                c.error("RBX5057", a.value.span, `${cls}(…) takes properties by name; only one positional argument (the Parent) is allowed`, [`${cls}(Name: "X", Parent: workspace)`]);
+                (0, exprs_js_1.checkExpr)(c, a.value);
+                continue;
+            }
+            parent = a.value;
+            const pt = (0, exprs_js_1.checkExpr)(c, a.value);
+            c.expectAssignable(types_js_1.T.option(types_js_1.T.instance("Instance")), pt, a.value.span, "Parent");
+            continue;
+        }
+        const hit = c.api.member(cls, a.name);
+        if (!hit || (hit.member.kind !== "property" && hit.member.kind !== "callback")) {
+            const props2 = [...c.api.members(cls)].filter(([, h]) => h.member.kind === "property").map(([n]) => n);
+            const s = (0, diagnostics_js_1.suggest)(a.name, props2);
+            c.error("RBX5058", a.nameSpan ?? a.value.span, `${cls} has no property '${a.name}'`, s ? [`did you mean '${s}'?`] : undefined);
+            (0, exprs_js_1.checkExpr)(c, a.value);
+            continue;
+        }
+        if (hit.member.readonly) {
+            c.error("RBX5030", a.nameSpan ?? a.value.span, `${hit.owner}.${a.name} is read-only`);
+        }
+        const want = hit.member.type ? c.api.convert(hit.member.type) : types_js_1.T.any;
+        const vt = (0, exprs_js_1.checkExpr)(c, a.value, want);
+        c.expectAssignable(want, vt, a.value.span, `${cls}.${a.name}`);
+        if (a.name === "Parent") {
+            parent = a.value;
+            continue;
+        }
+        props.push(a);
+    }
+    setCall(e, { form: "instance", cls, props, parent }, []);
+    return types_js_1.T.instance(cls);
+}
+function constructDatatype(c, e, name, args) {
+    if (name !== "Vector3" && name !== "Vector2") {
+        c.requireRoblox(e.callee.span, name);
+    }
+    const positional = args.filter((a) => a.name === null);
+    const named = args.filter((a) => a.name !== null);
+    const ctor = c.api.datatypeStatic(name, "new");
+    if (!ctor || ctor.kind !== "function") {
+        c.error("RBX5059", e.callee.span, `${name} has no constructor`, Object.keys(c.api.datatypes[name]?.statics ?? {}).length ? [`use ${name}.${Object.keys(c.api.datatypes[name].statics)[0]}(…)`] : undefined);
+        checkArgsLoose(c, e);
+        return types_js_1.T.datatype(name);
+    }
+    const fn = (0, types_js_1.prune)(c.api.staticFunctionType(ctor));
+    const fake = { kind: "Call", callee: e.callee, args: positional, span: e.span };
+    const r = checkArgs(c, fake, fn, e.callee.span, null);
+    for (const a of named) {
+        const m = c.api.datatypeMember(name, a.name);
+        if (!m || m.kind !== "property") {
+            c.error("RBX5058", a.nameSpan ?? a.value.span, `${name} has no property '${a.name}'`);
+            (0, exprs_js_1.checkExpr)(c, a.value);
+            continue;
+        }
+        const want = m.type ? c.api.convert(m.type) : types_js_1.T.any;
+        const vt = (0, exprs_js_1.checkExpr)(c, a.value, want);
+        c.expectAssignable(want, vt, a.value.span, `${name}.${a.name}`);
+    }
+    setCall(e, { form: "datatype", name, props: named }, r.args, r.rest);
+    return types_js_1.T.datatype(name);
+}
+function fireSignal(c, e, sym) {
+    sym.used = true;
+    e.callee.res = { kind: "signal", sym };
+    e.callee.ty = sym.type;
+    const types = checkArgsLoose(c, e);
+    if (sym.signalParams) {
+        if (types.length !== sym.signalParams.length) {
+            c.error("CL3102", e.span, `signal ${sym.name} passes ${sym.signalParams.length} value(s), got ${types.length}`);
+        }
+        types.forEach((t, i) => sym.signalParams[i] && c.expectAssignable(sym.signalParams[i], t, e.args[i].value.span, `signal ${sym.name}`));
+    }
+    setCall(e, { form: "signalFire", sym }, e.args.map((a) => a.value));
+    return types_js_1.T.void;
+}
+// ---------- generic calls ----------
+function finishCall(c, e, t, calleeSpan, form, expected, typeArgs) {
+    const p = (0, types_js_1.prune)(t);
+    const callee = e.callee;
+    const explicitTypeArgs = typeArgs ?? (callee.kind === "Name" ? callee.typeArgs : null);
+    if (p.k === "func") {
+        const decl = calleeDecl(c, callee);
+        const bindings = new Map();
+        if (explicitTypeArgs && explicitTypeArgs.length) {
+            const names = p.generics ?? [];
+            if (names.length !== explicitTypeArgs.length) {
+                c.error("CL3001", calleeSpan, `this function takes ${names.length} type argument(s), got ${explicitTypeArgs.length}`);
+            }
+            names.forEach((n, i) => explicitTypeArgs[i] && bindings.set(n, c.resolveType(explicitTypeArgs[i])));
+            for (const w of decl?.where ?? []) {
+                const bound = bindings.get(w.name);
+                const constraint = c.resolveType(w.type);
+                if (bound && (0, typeops_js_1.assignable)(c, constraint, bound) === "no") {
+                    c.error("CL3116", calleeSpan, `${w.name} must be ${(0, types_js_1.typeToString)(constraint)}, got ${(0, types_js_1.typeToString)(bound)}`);
+                }
+            }
+        }
+        const r = checkArgs(c, e, p, calleeSpan, decl, bindings);
+        setCall(e, form, r.args, r.rest);
+        const sym = callee.res && (callee.res.kind === "func" || callee.res.kind === "local") ? callee.res.sym : null;
+        if (sym?.contextOnly) {
+            c.checkContext(sym.contextOnly, calleeSpan, `${sym.name}()`, `it is marked [[${sym.contextOnly}]]`);
+        }
+        let ret = r.fn.ret;
+        if (decl && (0, types_js_1.prune)(ret).k === "infer" && !(0, types_js_1.prune)(ret).resolved) {
+            c.ensureBodyChecked(decl);
+            ret = r.fn.ret;
+        }
+        if (decl?.fn?.mayYield || (decl && c.isChecking(decl))) {
+            c.noteYield();
+        }
+        if (callee.kind === "Member" && callee.res?.kind === "method") {
+            const info = c.structs.get(callee.res.struct);
+            const m = info?.methods.get(callee.name);
+            const root = (0, exprs_js_1.rootSymbol)(callee.object);
+            if (m && root) {
+                c.mutatingCalls.push({ root, method: m, span: e.span });
+            }
+        }
+        const out = (0, typeops_js_1.substitute)((0, types_js_1.prune)(ret), bindings);
+        return (0, types_js_1.prune)(out).k === "infer" ? types_js_1.T.any : out;
+    }
+    checkArgsLoose(c, e);
+    setCall(e, form, e.args.map((a) => a.value));
+    if ((0, types_js_1.isDynamic)(p)) {
+        if (callee.kind === "Member" && callee.res?.kind === "dynamic" && /^[A-Z]/.test(callee.name) && c.strict) {
+            c.warn("CL3117", callee.nameSpan, `'${callee.name}' is called on a dynamic value; for a Luau method use '::'`, [`x::${callee.name}(…) emits x:${callee.name}(…)`]);
+        }
+        return types_js_1.T.any;
+    }
+    if (p.k === "clSignal") {
+        return types_js_1.T.void;
+    }
+    c.error("CL3118", calleeSpan, `${(0, types_js_1.typeToString)(p)} is not callable`);
+    void expected;
+    return types_js_1.T.unknown;
+}
+function calleeDecl(c, callee) {
+    const res = callee.res;
+    if (!res) {
+        return null;
+    }
+    if (res.kind === "func") {
+        return res.sym.decl ?? null;
+    }
+    if (res.kind === "method") {
+        return c.structs.get(res.struct)?.methods.get(callee.kind === "Member" || callee.kind === "SelfField" ? callee.name : "")?.decl ?? null;
+    }
+    return null;
+}
+/** Match arguments to parameters (named, defaults, variadic), choose an overload, bind generics. */
+function checkArgs(c, e, fn, calleeSpan, decl, bindings = new Map()) {
+    const overloads = fn.overloads ?? [fn];
+    let chosen = overloads[0];
+    if (overloads.length > 1) {
+        const positional = e.args.filter((a) => a.name === null).map((a) => (0, exprs_js_1.checkExpr)(c, a.value));
+        const fits = (o) => {
+            const required = o.params.filter((p) => !p.optional).length;
+            if (positional.length < required || (positional.length > o.params.length && !o.variadic)) {
+                return false;
+            }
+            return positional.every((t, i) => {
+                const want = o.params[i]?.type ?? o.variadic ?? types_js_1.T.any;
+                return (0, typeops_js_1.assignable)(c, want, t) === "ok";
+            });
+        };
+        const match = overloads.find(fits);
+        if (!match) {
+            const sigs = overloads.map((o) => `(${o.params.map((p) => `${p.name}: ${(0, types_js_1.typeToString)(p.type)}${p.optional ? "?" : ""}`).join(", ")})`);
+            c.error("CL3119", calleeSpan, `no overload accepts (${positional.map((t) => (0, types_js_1.typeToString)(t)).join(", ")})`, sigs.slice(0, 6).map((s) => `candidate ${s}`));
+            return { args: e.args.map((a) => a.value), rest: [], fn: chosen };
+        }
+        chosen = match;
+    }
+    const params = chosen.params;
+    const slots = params.map(() => null);
+    const rest = [];
+    let position = 0;
+    let named = false;
+    for (const a of e.args) {
+        if (a.name !== null) {
+            named = true;
+            const idx = params.findIndex((p) => p.name === a.name);
+            if (idx < 0) {
+                const s = (0, diagnostics_js_1.suggest)(a.name, params.map((p) => p.name));
+                c.error("CL3120", a.nameSpan ?? a.value.span, `no parameter named '${a.name}'`, s ? [`did you mean '${s}'?`] : [`parameters: ${params.map((p) => p.name).join(", ") || "none"}`]);
+                (0, exprs_js_1.checkExpr)(c, a.value);
+                continue;
+            }
+            if (slots[idx]) {
+                c.error("CL3121", a.nameSpan ?? a.value.span, `'${a.name}' is passed twice`);
+            }
+            slots[idx] = a.value;
+            continue;
+        }
+        if (named) {
+            c.error("CL3122", a.value.span, "positional arguments must come before named ones");
+        }
+        if (position < params.length) {
+            slots[position++] = a.value;
+        }
+        else if (chosen.variadic) {
+            rest.push(a.value);
+            position++;
+        }
+        else {
+            position++;
+        }
+    }
+    const given = e.args.length;
+    const max = chosen.variadic ? Infinity : params.length;
+    if (given > max) {
+        c.error("CL3123", calleeSpan, `wrong number of arguments: expected ${params.length}, got ${given}`);
+    }
+    params.forEach((p, i) => {
+        const arg = slots[i];
+        if (!arg) {
+            if (!p.optional) {
+                c.error("CL3124", calleeSpan, `missing argument '${p.name}' (${(0, types_js_1.typeToString)((0, typeops_js_1.substitute)(p.type, bindings))})`);
+            }
+            return;
+        }
+        let want = (0, typeops_js_1.substitute)(p.type, bindings);
+        const wantPruned = (0, types_js_1.prune)(want);
+        const learning = wantPruned.k === "infer" && !wantPruned.resolved;
+        const t = (0, exprs_js_1.checkExpr)(c, arg, learning ? undefined : want);
+        if (learning) {
+            // Learn the parameter type from its first call site.
+            const learned = (0, checker_js_1.widenLiteral)(t);
+            if ((0, types_js_1.prune)(learned).k !== "null" && !(0, types_js_1.isDynamic)(learned)) {
+                wantPruned.resolved = learned;
+            }
+            want = learned;
+        }
+        else {
+            (0, typeops_js_1.bindGenerics)(p.type, t, bindings);
+            want = (0, typeops_js_1.substitute)(p.type, bindings);
+            c.expectAssignable(want, t, arg.span, `argument '${p.name}'`);
+        }
+        if (decl) {
+            c.deferredCopies.push({ arg, decl, index: i });
+        }
+        else {
+            c.markCopy(arg);
+        }
+    });
+    for (const r of rest) {
+        const t = (0, exprs_js_1.checkExpr)(c, r, chosen.variadic ?? undefined);
+        if (chosen.variadic && !(0, types_js_1.isDynamic)(chosen.variadic)) {
+            c.expectAssignable((0, typeops_js_1.substitute)(chosen.variadic, bindings), t, r.span, "argument");
+        }
+        c.markCopy(r);
+    }
+    const resolvedFn = bindings.size ? (0, typeops_js_1.substitute)(chosen, bindings) : chosen;
+    return { args: trimTrailingNulls(slots), rest, fn: resolvedFn };
+}
+function trimTrailingNulls(args) {
+    let end = args.length;
+    while (end > 0 && args[end - 1] === null) {
+        end--;
+    }
+    return args.slice(0, end);
+}
+function joinTypes(c, types) {
+    return types.reduce((a, b) => (0, typeops_js_1.join)(c, a, b), types_js_1.T.never);
+}