cluaupp 1.5.2 → 2.0.0-beta.1

package/generated/compiler/checker/flow.js

@@ -0,0 +1,168 @@
+"use strict";
+/** Control flow facts: which statements always exit, and how conditions narrow nullable types. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alwaysExits = alwaysExits;
+exports.containsBreak = containsBreak;
+exports.conditionNarrowings = conditionNarrowings;
+exports.applyNarrowings = applyNarrowings;
+const types_js_1 = require("../types.js");
+const exprs_js_1 = require("./exprs.js");
+/** Does control never fall off the end of these statements? */
+function alwaysExits(c, body) {
+    for (const stmt of body) {
+        if (stmtExits(c, stmt)) {
+            return true;
+        }
+    }
+    return false;
+}
+function stmtExits(c, stmt) {
+    switch (stmt.kind) {
+        case "Return":
+            return true;
+        case "Output":
+            return stmt.channel === "report";
+        case "Expr":
+            return isNoReturnCall(stmt.expr);
+        case "If":
+            return stmt.else !== null && alwaysExits(c, stmt.then) && alwaysExits(c, stmt.else);
+        case "Block":
+            return alwaysExits(c, stmt.body);
+        case "Try":
+            return alwaysExits(c, stmt.body) && alwaysExits(c, stmt.handler);
+        case "Match": {
+            if (stmt.arms.length === 0) {
+                return false;
+            }
+            const exhaustive = stmt.exhaustive === true;
+            return exhaustive && stmt.arms.every((a) => alwaysExits(c, a.body));
+        }
+        case "Switch": {
+            const hasDefault = stmt.cases.some((k) => k.test === null);
+            return hasDefault && stmt.cases.every((k) => alwaysExits(c, k.body.filter((s) => s.kind !== "Break")));
+        }
+        case "While": {
+            const forever = isTrueLiteral(stmt.cond);
+            return forever && !containsBreak(stmt.body);
+        }
+        case "For":
+            return stmt.cond === null && !containsBreak(stmt.body);
+        default:
+            return false;
+    }
+}
+function isNoReturnCall(expr) {
+    if (expr.kind !== "Call") {
+        return false;
+    }
+    const callee = expr.callee;
+    return callee.kind === "Name" && callee.name === "error" && callee.res?.kind === "global";
+}
+function isTrueLiteral(e) {
+    return (e.kind === "Bool" && e.value) || (e.kind === "Number" && e.value !== 0);
+}
+/** `break` that targets this loop (not a nested loop or switch). */
+function containsBreak(body) {
+    for (const s of body) {
+        switch (s.kind) {
+            case "Break":
+                return true;
+            case "If":
+                if (containsBreak(s.then) || (s.else && containsBreak(s.else))) {
+                    return true;
+                }
+                break;
+            case "Block":
+                if (containsBreak(s.body)) {
+                    return true;
+                }
+                break;
+            case "Try":
+                if (containsBreak(s.body) || containsBreak(s.handler)) {
+                    return true;
+                }
+                break;
+            case "Match":
+                if (s.arms.some((a) => containsBreak(a.body))) {
+                    return true;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return false;
+}
+/** Narrowings that hold when `cond` evaluates to `truthy`. Types must already be on the nodes. */
+function conditionNarrowings(c, cond, truthy) {
+    switch (cond.kind) {
+        case "Unary":
+            if (cond.op === "not") {
+                return conditionNarrowings(c, cond.operand, !truthy);
+            }
+            return [];
+        case "Binary": {
+            if (cond.op === "and") {
+                return truthy ? [...conditionNarrowings(c, cond.left, true), ...conditionNarrowings(c, cond.right, true)] : [];
+            }
+            if (cond.op === "or") {
+                return truthy ? [] : [...conditionNarrowings(c, cond.left, false), ...conditionNarrowings(c, cond.right, false)];
+            }
+            if (cond.op === "==" || cond.op === "!=") {
+                const nullOnRight = cond.right.kind === "Null";
+                const nullOnLeft = cond.left.kind === "Null";
+                if (!nullOnLeft && !nullOnRight) {
+                    return [];
+                }
+                const subject = nullOnRight ? cond.left : cond.right;
+                const key = (0, exprs_js_1.exprPathKey)(subject);
+                if (!key || !subject.ty) {
+                    return [];
+                }
+                const notNull = cond.op === "!=" ? truthy : !truthy;
+                return [[key, notNull ? (0, types_js_1.nonNull)(subject.narrowedFrom ?? subject.ty) : types_js_1.T.null]];
+            }
+            return [];
+        }
+        case "Name":
+        case "Member":
+        case "SelfField": {
+            const key = (0, exprs_js_1.exprPathKey)(cond);
+            const t = cond.narrowedFrom ?? cond.ty;
+            if (!key || !t) {
+                return [];
+            }
+            const p = (0, types_js_1.prune)(t);
+            if (truthy && (p.k === "option" || p.k === "union")) {
+                return [[key, (0, types_js_1.nonNull)(p)]];
+            }
+            return [];
+        }
+        case "Call": {
+            // x.IsA("Part") / x.IsA<Part>()
+            const callee = cond.callee;
+            if (truthy && callee.kind === "Member" && callee.name === "IsA") {
+                const subject = callee.object;
+                const key = (0, exprs_js_1.exprPathKey)(subject);
+                let cls = null;
+                if (callee.typeArgs && callee.typeArgs[0]?.kind === "Named") {
+                    cls = callee.typeArgs[0].name;
+                }
+                else if (cond.args[0]?.value.kind === "String") {
+                    cls = cond.args[0].value.value;
+                }
+                if (key && cls && c.api.hasClass(cls)) {
+                    return [[key, types_js_1.T.instance(cls)]];
+                }
+            }
+            return [];
+        }
+        default:
+            return [];
+    }
+}
+function applyNarrowings(scope, narrowings) {
+    for (const [key, type] of narrowings) {
+        scope.narrowed.set(key, type);
+    }
+}