cluaupp 1.5.2 → 2.0.0-beta.1

package/generated/compiler/checker/symbols.js

@@ -0,0 +1,90 @@
+"use strict";
+/** Symbols, scopes and the per-module declaration registries shared by checker and emitter. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+exports.emptyExports = emptyExports;
+class Scope {
+    parent;
+    kind;
+    depth;
+    values = new Map();
+    types = new Map();
+    /** Narrowed types for paths (`sym#3`, `sym#3.Character`). */
+    narrowed = new Map();
+    constructor(parent, kind, depth) {
+        this.parent = parent;
+        this.kind = kind;
+        this.depth = depth;
+    }
+    lookup(name) {
+        let cur = this;
+        while (cur) {
+            const s = cur.values.get(name);
+            if (s) {
+                return s;
+            }
+            cur = cur.parent;
+        }
+        return undefined;
+    }
+    lookupType(name) {
+        let cur = this;
+        while (cur) {
+            const s = cur.types.get(name);
+            if (s) {
+                return s;
+            }
+            cur = cur.parent;
+        }
+        return undefined;
+    }
+    narrowedType(key) {
+        let cur = this;
+        while (cur) {
+            if (cur.narrowed.has(key)) {
+                return cur.narrowed.get(key);
+            }
+            cur = cur.parent;
+        }
+        return undefined;
+    }
+    /** Drop narrowings of a path and everything below it (after an assignment). */
+    invalidate(prefix) {
+        let cur = this;
+        while (cur) {
+            for (const key of [...cur.narrowed.keys()]) {
+                if (key === prefix || key.startsWith(`${prefix}.`)) {
+                    cur.narrowed.delete(key);
+                }
+            }
+            cur = cur.parent;
+        }
+        // Mark as explicitly unknown at this level so outer narrowings stop applying.
+    }
+    allValueNames() {
+        const out = [];
+        let cur = this;
+        while (cur) {
+            out.push(...cur.values.keys());
+            cur = cur.parent;
+        }
+        return out;
+    }
+}
+exports.Scope = Scope;
+function emptyExports(moduleId, file, kind, context) {
+    return {
+        moduleId,
+        file,
+        kind,
+        context,
+        funcs: new Map(),
+        structs: new Map(),
+        enums: new Map(),
+        variants: new Map(),
+        aliases: new Map(),
+        consts: new Map(),
+        namespaces: new Map(),
+        dmPath: null,
+    };
+}

package/generated/compiler/checker/typeops.js

@@ -0,0 +1,348 @@
+"use strict";
+/** Assignability, joins and member lookups that do not need checker state. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignable = assignable;
+exports.structExtends = structExtends;
+exports.join = join;
+exports.substitute = substitute;
+exports.bindGenerics = bindGenerics;
+const types_js_1 = require("../types.js");
+/**
+ * Can a value of type `from` be stored where `to` is expected?
+ * "nullable": only differs by a possible null (`Part?` into `Part`) — error in strict, warning otherwise.
+ * "narrowing": float into int — always an error (would lose the fraction).
+ */
+function assignable(env, to, from) {
+    const a = (0, types_js_1.prune)(to);
+    const b = (0, types_js_1.prune)(from);
+    if (a === b || (0, types_js_1.isDynamic)(a) || (0, types_js_1.isDynamic)(b) || b.k === "never") {
+        return "ok";
+    }
+    if (a.k === "infer") {
+        a.resolved = b;
+        return "ok";
+    }
+    if (a.k === "param" || b.k === "param") {
+        return "ok";
+    }
+    if (b.k === "union") {
+        let worst = "ok";
+        for (const m of b.members) {
+            const r = assignable(env, a, m);
+            if (r === "no") {
+                return "no";
+            }
+            if (r !== "ok") {
+                worst = r;
+            }
+        }
+        return worst;
+    }
+    switch (a.k) {
+        case "void":
+            return b.k === "void" ? "ok" : "no";
+        case "null":
+            return b.k === "null" ? "ok" : "no";
+        case "option": {
+            if (b.k === "null") {
+                return "ok";
+            }
+            if (b.k === "option") {
+                return assignable(env, a.inner, b.inner) === "no" ? "no" : assignable(env, a.inner, b.inner);
+            }
+            return assignable(env, a.inner, b);
+        }
+        case "union": {
+            let best = "no";
+            for (const m of a.members) {
+                const r = assignable(env, m, b);
+                if (r === "ok") {
+                    return "ok";
+                }
+                if (r !== "no") {
+                    best = r;
+                }
+            }
+            if (b.k === "null" && a.members.some((m) => (0, types_js_1.prune)(m).k === "null")) {
+                return "ok";
+            }
+            return best;
+        }
+        case "float":
+            return b.k === "float" || b.k === "int" || (b.k === "lit" && typeof b.value === "number") ? "ok" : nullableOr(env, a, b);
+        case "int":
+            if (b.k === "int" || (b.k === "lit" && typeof b.value === "number" && Number.isInteger(b.value))) {
+                return "ok";
+            }
+            if (b.k === "float" || (b.k === "lit" && typeof b.value === "number")) {
+                return "narrowing";
+            }
+            if (b.k === "enum") {
+                return "ok";
+            }
+            return nullableOr(env, a, b);
+        case "bool":
+            return b.k === "bool" || (b.k === "lit" && typeof b.value === "boolean") ? "ok" : nullableOr(env, a, b);
+        case "string":
+            return b.k === "string" || (b.k === "lit" && typeof b.value === "string") ? "ok" : nullableOr(env, a, b);
+        case "lit":
+            return b.k === "lit" && b.value === a.value ? "ok" : nullableOr(env, a, b);
+        case "list":
+            if (b.k === "list") {
+                if (!a.typed || !b.typed) {
+                    return "ok";
+                }
+                const r = assignable(env, a.elem, b.elem);
+                return r === "ok" || r === "nullable" ? r : "no";
+            }
+            if (b.k === "tuple") {
+                return b.elems.every((e) => assignable(env, a.elem, e) === "ok") ? "ok" : "no";
+            }
+            return nullableOr(env, a, b);
+        case "dict":
+            if (b.k === "dict") {
+                return assignable(env, a.key, b.key) !== "no" && assignable(env, a.value, b.value) !== "no" ? "ok" : "no";
+            }
+            if (b.k === "table") {
+                return Object.values(b.fields).every((f) => assignable(env, a.value, f) !== "no") ? "ok" : "no";
+            }
+            return nullableOr(env, a, b);
+        case "table":
+            if (b.k === "table") {
+                for (const [k, v] of Object.entries(a.fields)) {
+                    const bf = b.fields[k];
+                    if (!bf) {
+                        if ((0, types_js_1.prune)(v).k !== "option") {
+                            return "no";
+                        }
+                        continue;
+                    }
+                    if (assignable(env, v, bf) === "no") {
+                        return "no";
+                    }
+                }
+                return "ok";
+            }
+            if (b.k === "dict") {
+                return "ok";
+            }
+            return nullableOr(env, a, b);
+        case "struct":
+            if (b.k === "struct") {
+                if (a.id === b.id) {
+                    return a.args.length === 0 || b.args.length === 0 || a.args.every((x, i) => (0, types_js_1.sameType)(x, b.args[i] ?? types_js_1.T.any)) ? "ok" : "no";
+                }
+                return structExtends(env, b.id, a.id) ? "ok" : "no";
+            }
+            return nullableOr(env, a, b);
+        case "enum":
+        case "variant":
+            if (b.k === a.k && b.id === a.id) {
+                return "ok";
+            }
+            if (a.k === "variant") {
+                return a.alternatives.some((alt) => assignable(env, alt, b) === "ok") ? "ok" : nullableOr(env, a, b);
+            }
+            return nullableOr(env, a, b);
+        case "result":
+            if (b.k === "result") {
+                const ok = assignable(env, a.ok, b.ok);
+                const err = assignable(env, a.err, b.err);
+                return ok !== "no" && err !== "no" ? "ok" : "no";
+            }
+            return nullableOr(env, a, b);
+        case "task":
+            return b.k === "task" ? "ok" : nullableOr(env, a, b);
+        case "func":
+            if (b.k === "func") {
+                return "ok";
+            }
+            return nullableOr(env, a, b);
+        case "instance":
+            if (b.k === "instance") {
+                return b.cls === a.cls || env.api.isA(b.cls, a.cls) ? "ok" : "no";
+            }
+            return nullableOr(env, a, b);
+        case "datatype":
+            if (b.k === "datatype") {
+                return b.name === a.name ? "ok" : "no";
+            }
+            return nullableOr(env, a, b);
+        case "rbxEnumItem":
+            if (b.k === "rbxEnumItem") {
+                return a.enumName === "*" || b.enumName === a.enumName || b.enumName === "*" ? "ok" : "no";
+            }
+            return nullableOr(env, a, b);
+        case "rbxEnum":
+            return b.k === "rbxEnum" && (a.enumName === "*" || a.enumName === b.enumName) ? "ok" : "no";
+        case "rbxSignal":
+            return b.k === "rbxSignal" ? "ok" : "no";
+        case "tuple":
+            return b.k === "tuple" && b.elems.length >= a.elems.length ? "ok" : "no";
+        case "thread":
+        case "buffer":
+            return b.k === a.k ? "ok" : nullableOr(env, a, b);
+        default:
+            return (0, types_js_1.sameType)(a, b) ? "ok" : "no";
+    }
+}
+function nullableOr(env, to, from) {
+    if (from.k === "option") {
+        return assignable(env, to, from.inner) === "ok" ? "nullable" : "no";
+    }
+    if (from.k === "null") {
+        return "nullable";
+    }
+    return "no";
+}
+function structExtends(env, childId, baseId) {
+    const seen = new Set();
+    const stack = [childId];
+    while (stack.length) {
+        const id = stack.pop();
+        if (id === baseId) {
+            return true;
+        }
+        if (seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        const info = env.struct(id);
+        if (info) {
+            stack.push(...info.bases);
+        }
+    }
+    return false;
+}
+/** Least upper bound used for ternaries, list literals and inferred returns. */
+function join(env, a, b) {
+    const x = (0, types_js_1.prune)(a);
+    const y = (0, types_js_1.prune)(b);
+    if ((0, types_js_1.isDynamic)(x)) {
+        return y;
+    }
+    if ((0, types_js_1.isDynamic)(y)) {
+        return x;
+    }
+    if (x.k === "never") {
+        return y;
+    }
+    if (y.k === "never") {
+        return x;
+    }
+    if ((0, types_js_1.sameType)(x, y)) {
+        return x;
+    }
+    if (x.k === "null") {
+        return types_js_1.T.option(y);
+    }
+    if (y.k === "null") {
+        return types_js_1.T.option(x);
+    }
+    if (x.k === "option" || y.k === "option") {
+        const inner = join(env, x.k === "option" ? x.inner : x, y.k === "option" ? y.inner : y);
+        return types_js_1.T.option(inner);
+    }
+    const numeric = (t) => t.k === "int" || t.k === "float" || (t.k === "lit" && typeof t.value === "number");
+    if (numeric(x) && numeric(y)) {
+        const isInt = (t) => t.k === "int" || (t.k === "lit" && Number.isInteger(t.value));
+        return isInt(x) && isInt(y) ? types_js_1.T.int : types_js_1.T.float;
+    }
+    if (x.k === "lit" && y.k === "lit" && typeof x.value === typeof y.value) {
+        return typeof x.value === "string" ? types_js_1.T.string : typeof x.value === "boolean" ? types_js_1.T.bool : types_js_1.T.float;
+    }
+    if ((x.k === "lit" && typeof x.value === "string" && y.k === "string") || (y.k === "lit" && typeof y.value === "string" && x.k === "string")) {
+        return types_js_1.T.string;
+    }
+    if (x.k === "instance" && y.k === "instance") {
+        return types_js_1.T.instance(commonClass(env, x.cls, y.cls));
+    }
+    if (x.k === "struct" && y.k === "struct") {
+        if (structExtends(env, x.id, y.id)) {
+            return y;
+        }
+        if (structExtends(env, y.id, x.id)) {
+            return x;
+        }
+    }
+    if (x.k === "list" && y.k === "list") {
+        return types_js_1.T.list(join(env, x.elem, y.elem), x.typed && y.typed);
+    }
+    return { k: "union", members: [x, y] };
+}
+function commonClass(env, a, b) {
+    const chain = new Set();
+    let cur = a;
+    while (cur) {
+        chain.add(cur);
+        cur = env.api.classes[cur]?.superclass ?? null;
+    }
+    cur = b;
+    while (cur) {
+        if (chain.has(cur)) {
+            return cur;
+        }
+        cur = env.api.classes[cur]?.superclass ?? null;
+    }
+    return "Instance";
+}
+/** Replace generic parameters by their bindings. */
+function substitute(t, bindings) {
+    if (bindings.size === 0) {
+        return t;
+    }
+    const p = (0, types_js_1.prune)(t);
+    switch (p.k) {
+        case "param":
+            return bindings.get(p.name) ?? p;
+        case "list":
+            return types_js_1.T.list(substitute(p.elem, bindings), p.typed);
+        case "dict":
+            return types_js_1.T.dict(substitute(p.key, bindings), substitute(p.value, bindings));
+        case "option":
+            return types_js_1.T.option(substitute(p.inner, bindings));
+        case "result":
+            return { k: "result", ok: substitute(p.ok, bindings), err: substitute(p.err, bindings) };
+        case "task":
+            return { k: "task", result: substitute(p.result, bindings) };
+        case "struct":
+            return p.args.length ? { ...p, args: p.args.map((x) => substitute(x, bindings)) } : p;
+        case "func":
+            return {
+                ...p,
+                params: p.params.map((x) => ({ ...x, type: substitute(x.type, bindings) })),
+                ret: substitute(p.ret, bindings),
+                variadic: p.variadic ? substitute(p.variadic, bindings) : null,
+            };
+        case "union":
+            return { k: "union", members: p.members.map((m) => substitute(m, bindings)) };
+        case "tuple":
+            return { k: "tuple", elems: p.elems.map((m) => substitute(m, bindings)) };
+        default:
+            return p;
+    }
+}
+/** Bind generic parameters by matching a declared type against an argument type. */
+function bindGenerics(declared, actual, bindings) {
+    const d = (0, types_js_1.prune)(declared);
+    const a = (0, types_js_1.prune)(actual);
+    if (d.k === "param") {
+        if (!bindings.has(d.name) && !(0, types_js_1.isDynamic)(a)) {
+            bindings.set(d.name, a.k === "lit" ? (typeof a.value === "string" ? types_js_1.T.string : typeof a.value === "boolean" ? types_js_1.T.bool : Number.isInteger(a.value) ? types_js_1.T.int : types_js_1.T.float) : a);
+        }
+        return;
+    }
+    if (d.k === "list" && a.k === "list") {
+        bindGenerics(d.elem, a.elem, bindings);
+    }
+    else if (d.k === "option") {
+        bindGenerics(d.inner, a.k === "option" ? a.inner : a, bindings);
+    }
+    else if (d.k === "dict" && a.k === "dict") {
+        bindGenerics(d.key, a.key, bindings);
+        bindGenerics(d.value, a.value, bindings);
+    }
+    else if (d.k === "struct" && a.k === "struct") {
+        d.args.forEach((x, i) => a.args[i] && bindGenerics(x, a.args[i], bindings));
+    }
+}

package/generated/compiler/checker/yields.js

@@ -0,0 +1,115 @@
+"use strict";
+/** Can executing these statements yield the current thread (task.wait, WaitForChild, *Async, :Wait())? */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mayYield = mayYield;
+const types_js_1 = require("../types.js");
+const YIELDING_GLOBALS = new Set(["wait", "Wait"]);
+const YIELDING_LIBRARY = new Set(["task.wait", "coroutine.yield"]);
+function mayYield(c, body) {
+    let found = false;
+    const visitExpr = (e) => {
+        if (!e || found) {
+            return;
+        }
+        if (exprYields(c, e)) {
+            found = true;
+            return;
+        }
+        for (const [key, value] of Object.entries(e)) {
+            if (key === "ty" || key === "res" || key === "span" || key === "narrowedFrom") {
+                continue;
+            }
+            if (key === "body" && e.kind === "Function") {
+                continue; // a closure's body runs later
+            }
+            walk(value);
+        }
+    };
+    const walk = (node) => {
+        if (found || !node || typeof node !== "object") {
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const n of node) {
+                walk(n);
+            }
+            return;
+        }
+        const rec = node;
+        if (rec.kind && isExprKind(rec.kind)) {
+            visitExpr(node);
+            return;
+        }
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "ty" || key === "res" || key === "span" || key === "sym") {
+                continue;
+            }
+            walk(value);
+        }
+    };
+    walk(body);
+    return found;
+}
+const EXPR_KINDS = new Set([
+    "Number", "String", "Template", "Bool", "Null", "Name", "SelfField", "Member", "Scope", "Index", "Call", "New", "Unary",
+    "Binary", "Ternary", "Function", "Spawn", "Await", "Thread", "Join", "Move", "PCall", "Parallel", "Update", "Cast", "Error",
+]);
+function isExprKind(kind) {
+    return EXPR_KINDS.has(kind);
+}
+function exprYields(c, e) {
+    if (e.kind === "Await" || e.kind === "Join" || e.kind === "Parallel") {
+        return true;
+    }
+    if (e.kind !== "Call") {
+        return false;
+    }
+    const callee = e.callee;
+    const res = callee.res;
+    if (!res) {
+        return true;
+    }
+    switch (res.kind) {
+        case "rbxMethod": {
+            const name = callee.kind === "Member" || callee.kind === "Scope" ? callee.name : "";
+            const hit = c.api.member(res.owner, name);
+            return Boolean(hit?.member.yields) || name === "WaitForChild" || /Async$/.test(name);
+        }
+        case "datatypeMember":
+            return res.datatype === "RBXScriptSignal" && res.member === "Wait";
+        case "global":
+            return YIELDING_GLOBALS.has(res.luau);
+        case "library":
+            return YIELDING_LIBRARY.has(`${res.lib}.${res.member}`);
+        case "func":
+        case "local": {
+            const decl = res.sym.decl;
+            if (decl) {
+                return decl.fn?.mayYield ?? true;
+            }
+            const t = (0, types_js_1.prune)(callee.ty ?? { k: "any" });
+            return t.k !== "func";
+        }
+        case "method": {
+            const info = c.structs.get(res.struct);
+            const m = info?.methods.get(res.name);
+            return m?.decl.fn?.mayYield ?? true;
+        }
+        case "moduleMember":
+            return true;
+        case "builtin":
+        case "stdlib":
+        case "datatypeStatic":
+        case "rbxProperty":
+        case "rbxEvent":
+        case "enumCase":
+        case "struct":
+        case "signal":
+            return false;
+        case "dynamic":
+        case "luauMethod":
+            return true;
+        default:
+            return false;
+    }
+}

package/generated/compiler/diagnostics.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticBag = void 0;
+exports.hasErrors = hasErrors;
+exports.sortDiagnostics = sortDiagnostics;
+exports.formatDiagnostic = formatDiagnostic;
+exports.editDistance = editDistance;
+exports.suggest = suggest;
+class DiagnosticBag {
+    source;
+    items = [];
+    seen = new Set();
+    constructor(source) {
+        this.source = source;
+    }
+    add(code, severity, span, message, notes, fix) {
+        const start = this.source.position(span.start);
+        const end = this.source.position(Math.max(span.start, span.end));
+        const diagnostic = {
+            code,
+            severity,
+            message,
+            file: this.source.path,
+            span,
+            line: start.line,
+            column: start.column,
+            endLine: end.line,
+            endColumn: end.column,
+        };
+        if (notes && notes.length > 0) {
+            diagnostic.notes = notes;
+        }
+        if (fix) {
+            diagnostic.fix = fix;
+        }
+        const key = `${code}:${span.start}:${span.end}:${message}`;
+        if (!this.seen.has(key)) {
+            this.seen.add(key);
+            this.items.push(diagnostic);
+        }
+        return diagnostic;
+    }
+    error(code, span, message, notes, fix) {
+        return this.add(code, "error", span, message, notes, fix);
+    }
+    warning(code, span, message, notes, fix) {
+        return this.add(code, "warning", span, message, notes, fix);
+    }
+    info(code, span, message, notes) {
+        return this.add(code, "info", span, message, notes);
+    }
+    get errorCount() {
+        let n = 0;
+        for (const d of this.items) {
+            if (d.severity === "error") {
+                n++;
+            }
+        }
+        return n;
+    }
+}
+exports.DiagnosticBag = DiagnosticBag;
+function hasErrors(diagnostics) {
+    return diagnostics.some((d) => d.severity === "error");
+}
+function sortDiagnostics(diagnostics) {
+    return diagnostics.sort((a, b) => a.file.localeCompare(b.file) || a.span.start - b.span.start || a.code.localeCompare(b.code));
+}
+/** `file:line:col: error[CL3001]: message` plus a caret excerpt, like rustc/clang. */
+function formatDiagnostic(d, source, color = false) {
+    const paint = (code, text) => (color ? `\x1b[${code}m${text}\x1b[0m` : text);
+    const label = d.severity === "error" ? paint("1;31", "error") : d.severity === "warning" ? paint("1;33", "warning") : paint("1;36", d.severity);
+    const lines = [`${d.file}:${d.line}:${d.column}: ${label}[${d.code}]: ${d.message}`];
+    if (source) {
+        const text = source.lineText(d.line).replace(/\t/g, "    ");
+        const raw = source.lineText(d.line);
+        const prefix = raw.slice(0, d.column - 1).replace(/\t/g, "    ");
+        const width = d.endLine === d.line ? Math.max(1, d.endColumn - d.column) : Math.max(1, raw.length - (d.column - 1));
+        const gutter = String(d.line).length;
+        lines.push(`${" ".repeat(gutter)} |`);
+        lines.push(`${d.line} | ${text}`);
+        lines.push(`${" ".repeat(gutter)} | ${" ".repeat(prefix.length)}${paint(d.severity === "error" ? "1;31" : "1;33", "^".repeat(Math.min(width, Math.max(1, text.length - prefix.length))))}`);
+    }
+    for (const note of d.notes || []) {
+        lines.push(`  = ${note}`);
+    }
+    return lines.join("\n");
+}
+/** Damerau-free Levenshtein, capped; used for "did you mean" suggestions. */
+function editDistance(a, b, cap = 4) {
+    if (Math.abs(a.length - b.length) > cap) {
+        return cap + 1;
+    }
+    const prev = new Array(b.length + 1);
+    const cur = new Array(b.length + 1);
+    for (let j = 0; j <= b.length; j++) {
+        prev[j] = j;
+    }
+    for (let i = 1; i <= a.length; i++) {
+        cur[0] = i;
+        let rowMin = cur[0];
+        const ca = a.charCodeAt(i - 1);
+        for (let j = 1; j <= b.length; j++) {
+            const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
+            cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+            if (cur[j] < rowMin) {
+                rowMin = cur[j];
+            }
+        }
+        if (rowMin > cap) {
+            return cap + 1;
+        }
+        for (let j = 0; j <= b.length; j++) {
+            prev[j] = cur[j];
+        }
+    }
+    return prev[b.length];
+}
+function suggest(name, candidates, max = 2) {
+    let best = null;
+    let bestScore = Infinity;
+    const lower = name.toLowerCase();
+    for (const candidate of candidates) {
+        if (candidate === name) {
+            continue;
+        }
+        if (candidate.toLowerCase() === lower) {
+            return candidate;
+        }
+        const limit = Math.min(max, Math.max(1, Math.floor(name.length / 3)));
+        const score = editDistance(lower, candidate.toLowerCase(), limit);
+        if (score <= limit && score < bestScore) {
+            best = candidate;
+            bestScore = score;
+        }
+    }
+    return best;
+}