cluaupp 1.5.2 → 2.0.0-beta.1

package/src/compiler/checker/flow.ts

@@ -0,0 +1,174 @@
+/** Control flow facts: which statements always exit, and how conditions narrow nullable types. */
+
+import type { Expr, Stmt } from "../ast.js";
+import { nonNull, prune, T, type Type } from "../types.js";
+import type { Checker } from "./checker.js";
+import { exprPathKey } from "./exprs.js";
+import type { Scope } from "./symbols.js";
+
+/** Does control never fall off the end of these statements? */
+export function alwaysExits(c: Checker, body: Stmt[]): boolean {
+	for (const stmt of body) {
+		if (stmtExits(c, stmt)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function stmtExits(c: Checker, stmt: Stmt): boolean {
+	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: Expr): boolean {
+	if (expr.kind !== "Call") {
+		return false;
+	}
+	const callee = expr.callee;
+	return callee.kind === "Name" && callee.name === "error" && callee.res?.kind === "global";
+}
+
+function isTrueLiteral(e: Expr): boolean {
+	return (e.kind === "Bool" && e.value) || (e.kind === "Number" && e.value !== 0);
+}
+
+/** `break` that targets this loop (not a nested loop or switch). */
+export function containsBreak(body: Stmt[]): boolean {
+	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;
+}
+
+export type Narrowing = [string, Type];
+
+/** Narrowings that hold when `cond` evaluates to `truthy`. Types must already be on the nodes. */
+export function conditionNarrowings(c: Checker, cond: Expr, truthy: boolean): Narrowing[] {
+	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 = exprPathKey(subject);
+				if (!key || !subject.ty) {
+					return [];
+				}
+				const notNull = cond.op === "!=" ? truthy : !truthy;
+				return [[key, notNull ? nonNull(subject.narrowedFrom ?? subject.ty) : T.null]];
+			}
+			return [];
+		}
+		case "Name":
+		case "Member":
+		case "SelfField": {
+			const key = exprPathKey(cond);
+			const t = cond.narrowedFrom ?? cond.ty;
+			if (!key || !t) {
+				return [];
+			}
+			const p = prune(t);
+			if (truthy && (p.k === "option" || p.k === "union")) {
+				return [[key, 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 = exprPathKey(subject);
+				let cls: string | null = 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, T.instance(cls)]];
+				}
+			}
+			return [];
+		}
+		default:
+			return [];
+	}
+}
+
+export function applyNarrowings(scope: Scope, narrowings: Narrowing[]): void {
+	for (const [key, type] of narrowings) {
+		scope.narrowed.set(key, type);
+	}
+}