pi-pstack-native 0.0.0-stage → 1.0.0

package/dist/statechart/passes/lift.js

@@ -0,0 +1,89 @@
+import { append, must, tupleKey, unkey, } from "../ir.js";
+export function liftToParents(states, steps) {
+    const depths = new Map();
+    const leaves = new Map();
+    for (const s of states.values())
+        for (let i = 1; i < s.path.length; i++) {
+            const prefix = tupleKey(s.path.slice(0, i));
+            depths.set(prefix, i);
+            leaves.set(prefix, (leaves.get(prefix) ?? 0) + 1);
+        }
+    if (!depths.size)
+        return steps;
+    const leaving = new Map();
+    for (const s of steps) {
+        let same = 0;
+        while (same < s.from.length && s.from[same] === s.to[same])
+            same++;
+        for (let i = 1; i < s.from.length; i++) {
+            if (i <= same && i < s.to.length)
+                continue;
+            const prefix = tupleKey(s.from.slice(0, i));
+            if (depths.has(prefix))
+                append(leaving, prefix, s);
+        }
+    }
+    const removed = new Set();
+    const lifted = [];
+    for (const [prefix] of [...depths].sort((a, b) => a[1] - b[1])) {
+        const groups = new Map();
+        for (const s of leaving.get(prefix) ?? [])
+            if (!removed.has(s))
+                append(groups, tupleKey([s.label, s.when, s.to]), s);
+        const under = must(leaves, prefix);
+        for (const group of groups.values()) {
+            if (under < 2 || group.length < under)
+                continue;
+            for (const s of group)
+                removed.add(s);
+            lifted.push({ ...group[0], from: unkey(prefix) });
+        }
+    }
+    const kept = [];
+    for (const s of steps)
+        if (!removed.has(s))
+            kept.push(s);
+    for (const s of lifted)
+        kept.push(s);
+    return kept;
+}
+export function lift(chart) {
+    const regions = [];
+    for (const r of chart.regions) {
+        const known = new Map();
+        for (const s of r.states)
+            known.set(s.path, known.size);
+        let numbers;
+        const pathIndex = (path) => {
+            let i = known.get(path);
+            if (i !== undefined)
+                return i;
+            if (!numbers) {
+                numbers = new Map();
+                for (const s of r.states)
+                    numbers.set(tupleKey(s.path), numbers.size);
+            }
+            const k = tupleKey(path);
+            i = numbers.get(k);
+            if (i === undefined)
+                numbers.set(k, (i = numbers.size));
+            known.set(path, i);
+            return i;
+        };
+        const merged = new Map();
+        for (const s of liftToParents(r.states, r.steps)) {
+            const f = pathIndex(s.from);
+            const t = pathIndex(s.to);
+            const k = s.when === undefined && f < 2 ** 26 && t < 2 ** 26
+                ? f * 2 ** 26 + t
+                : `${f},${t}:${s.when}`;
+            const prior = merged.get(k);
+            if (prior)
+                prior.label += ` or ${s.label}`;
+            else
+                merged.set(k, { ...s });
+        }
+        regions.push({ ...r, steps: [...merged.values()] });
+    }
+    return { ...chart, regions };
+}

package/dist/statechart/passes/loop-check.js

@@ -0,0 +1,57 @@
+import { append, holds, loopOf, must, tupleKey, unkey, } from "../ir.js";
+export function loopCheck({ regions, loops }, { names, keys, drawnLabels, sorted }, { index, from, to }, found) {
+    const R = names.length;
+    const combo = (i) => {
+        const parts = [];
+        for (let r = 0; r < R; r++)
+            parts.push(keys[r][i]);
+        return tupleKey(parts);
+    };
+    const stepsFrom = new Map();
+    const arrowsFrom = [];
+    if (loops.length) {
+        for (const j of sorted)
+            append(stepsFrom, from[j], j);
+        for (const { arrows } of regions) {
+            const out = new Map();
+            for (const a of arrows)
+                append(out, a.from, a);
+            arrowsFrom.push(out);
+        }
+    }
+    for (const b of found) {
+        if (b.loop === undefined)
+            continue;
+        const inLoop = new Set();
+        const twinsOf = new Map();
+        for (const i of loopOf(b, index)) {
+            inLoop.add(combo(i));
+            append(twinsOf, combo(i), i);
+        }
+        for (const i of loopOf(b, index)) {
+            const twins = must(twinsOf, combo(i));
+            for (const [r, name] of names.entries()) {
+                const takes = (a) => {
+                    for (const s of twins)
+                        for (const j of stepsFrom.get(s) ?? [])
+                            if (drawnLabels[j] === a.label && keys[r][to[j]] === a.to)
+                                return true;
+                    return false;
+                };
+                const rest = [];
+                for (let o = 0; o < R; o++)
+                    if (o !== r)
+                        rest.push(keys[o][i]);
+                for (const a of arrowsFrom[r].get(keys[r][i]) ?? []) {
+                    if (!holds(a.condition, rest))
+                        continue;
+                    const next = [];
+                    for (let o = 0; o < R; o++)
+                        next.push(o === r ? a.to : keys[o][i]);
+                    if (!inLoop.has(tupleKey(next)) && !takes(a))
+                        throw new Error(`The chart draws the step ${a.label} out of ${name ? `${name} ` : ""}${unkey(a.from).join(" / ")}, but the ${b.rule.name} loop cannot take it there. Show in a label what stops it.`);
+                }
+            }
+        }
+    }
+}

package/dist/statechart/passes/paths.js

@@ -0,0 +1,50 @@
+import { hasRule, must, stateKey, } from "../ir.js";
+export function pathGraph(names) {
+    const graph = { states: new Map(), steps: [] };
+    const ids = new Map();
+    const taken = new Map();
+    const idOf = (vars, start) => {
+        if (!vars)
+            throw new Error("TLC's trace has a state with no values.");
+        const k = stateKey(names.map((name) => vars[name]));
+        let id = ids.get(k);
+        if (id === undefined) {
+            ids.set(k, (id = String(ids.size)));
+            graph.states.set(id, { vars, start, breaks: [] });
+        }
+        else if (start)
+            must(graph.states, id).start = true;
+        return id;
+    };
+    const route = (seq) => {
+        const start = idOf(seq[0].vars, true);
+        const path = [];
+        let from = start;
+        for (let i = 1; i < seq.length; i++) {
+            const { action } = seq[i];
+            const to = idOf(seq[i].vars, false);
+            const k = `${from} ${to} ${action}`;
+            let step = taken.get(k);
+            if (!step) {
+                taken.set(k, (step = { from, to, action }));
+                graph.steps.push(step);
+            }
+            path.push({ action, state: to, step });
+            from = to;
+        }
+        return { start, path };
+    };
+    return {
+        graph,
+        bug: (rule, trace) => {
+            if (!trace.length)
+                throw new Error(`TLC's trace for ${rule.name} has no states.`);
+            const bug = { rule, ...route(trace) };
+            const end = must(graph.states, bug.path.at(-1)?.state ?? bug.start);
+            if (!hasRule(end.breaks, rule))
+                end.breaks.push(rule);
+            return bug;
+        },
+        lasso: ({ seq, loop }) => seq.length ? { ...route(seq), loop, stutters: loop === seq.length - 1 } : undefined,
+    };
+}

package/dist/statechart/passes/reach.js

@@ -0,0 +1,134 @@
+import { byText, count, defaultState, must, ruleKey, sortBy, } from "../ir.js";
+export function walk(graph) {
+    const ids = [];
+    const states = [];
+    const nameOf = [];
+    const starts = [];
+    const unique = new Set();
+    for (const [id, s] of graph.states) {
+        const name = defaultState(s.vars);
+        if (s.start)
+            starts.push(ids.length);
+        ids.push(id);
+        states.push(s);
+        nameOf.push(name);
+        unique.add(name);
+    }
+    const names = Array.from(unique).sort(byText);
+    const rankOf = new Map();
+    for (let i = 0; i < names.length; i++)
+        rankOf.set(names[i], i);
+    const n = ids.length;
+    const index = new Map();
+    const nameRank = new Int32Array(n);
+    for (let i = 0; i < n; i++) {
+        index.set(ids[i], i);
+        nameRank[i] = must(rankOf, nameOf[i]);
+    }
+    const m = graph.steps.length;
+    const from = new Int32Array(m);
+    const to = new Int32Array(m);
+    const action = new Int32Array(m);
+    const actions = new Map();
+    for (let j = 0; j < m; j++) {
+        const t = graph.steps[j];
+        from[j] = must(index, t.from);
+        to[j] = must(index, t.to);
+        let a = actions.get(t.action);
+        if (a === undefined)
+            actions.set(t.action, (a = actions.size));
+        action[j] = a;
+    }
+    const actionRank = new Int32Array(actions.size);
+    for (const [i, a] of [...actions.keys()].sort(byText).entries())
+        actionRank[must(actions, a)] = i;
+    const toName = new Int32Array(m);
+    for (let j = 0; j < m; j++) {
+        action[j] = actionRank[action[j]];
+        toName[j] = nameRank[to[j]];
+    }
+    const first = new Int32Array(n + 1);
+    for (let j = 0; j < m; j++)
+        first[from[j] + 1]++;
+    for (let i = 0; i < n; i++)
+        first[i + 1] += first[i];
+    const fill = first.slice(0, n);
+    const next = new Int32Array(m);
+    for (const j of sortBy(count(m), [action, toName]))
+        next[fill[from[j]]++] = j;
+    starts.sort((a, b) => nameRank[a] - nameRank[b]);
+    const depth = new Int32Array(n).fill(-1);
+    const via = new Int32Array(n).fill(-1);
+    const reached = new Int32Array(n);
+    let size = 0;
+    for (const s of starts) {
+        depth[s] = 0;
+        reached[size++] = s;
+    }
+    for (let q = 0; q < size; q++) {
+        const s = reached[q];
+        for (let e = first[s]; e < first[s + 1]; e++) {
+            const t = to[next[e]];
+            if (depth[t] >= 0)
+                continue;
+            depth[t] = depth[s] + 1;
+            via[t] = next[e];
+            reached[size++] = t;
+        }
+    }
+    return {
+        ids,
+        states,
+        index,
+        nameOf,
+        nameRank,
+        from,
+        to,
+        action,
+        depth,
+        via,
+        reached: reached.subarray(0, size),
+        starts,
+    };
+}
+export function drawOrder({ depth, nameRank }) {
+    const n = depth.length;
+    let deepest = 0;
+    for (let i = 0; i < n; i++)
+        if (depth[i] > deepest)
+            deepest = depth[i];
+    const level = new Int32Array(n);
+    for (let i = 0; i < n; i++)
+        level[i] = depth[i] < 0 ? deepest + 1 : depth[i];
+    const order = sortBy(count(n), [level, nameRank]);
+    const rank = new Int32Array(n);
+    for (let p = 0; p < n; p++)
+        rank[order[p]] = p;
+    return { order, rank };
+}
+export function bugs(graph, { ids, from, via, reached } = walk(graph)) {
+    const ends = new Map();
+    for (const [id, s] of graph.states)
+        for (const rule of s.ends ?? [])
+            ends.set(ruleKey(rule), id);
+    const first = new Map();
+    for (const i of reached) {
+        const s = must(graph.states, ids[i]);
+        for (const rule of s.past ? s.ends : s.breaks) {
+            const k = ruleKey(rule);
+            if (!first.has(k) && (ends.get(k) ?? ids[i]) === ids[i])
+                first.set(k, { rule, i });
+        }
+    }
+    const found = [];
+    for (const { rule, i } of first.values()) {
+        const path = [];
+        let start = i;
+        for (let j; (j = via[start]) >= 0; start = from[j]) {
+            const step = graph.steps[j];
+            path.unshift({ action: step.action, state: step.to, step });
+        }
+        found.push({ rule, start: ids[start], path });
+    }
+    return found;
+}

package/dist/statechart/passes/region-check.js

@@ -0,0 +1,94 @@
+import { append, holds, tupleKey, unkey, } from "../ir.js";
+export function regionsLie(regions, { names, keys, sorted, drawnLabels, together }, { from, to, starts }, order) {
+    if (names.length < 2)
+        return undefined;
+    const combo = (i) => {
+        const c = [];
+        for (let r = 0; r < names.length; r++)
+            c.push(keys[r][i]);
+        return c;
+    };
+    const words = (c) => {
+        const parts = [];
+        for (let i = 0; i < names.length; i++)
+            parts.push(`${names[i]} ${unkey(c[i]).join(" / ")}`);
+        return parts.join(", ");
+    };
+    const addMove = (moves, m) => moves.set(tupleKey([m.from, m.text, m.to]), m);
+    let product = [[]];
+    for (const r of regions) {
+        const next = [];
+        for (const c of product)
+            for (const s of r.states)
+                if (s.start)
+                    next.push([...c, tupleKey(s.path)]);
+        product = next;
+    }
+    const realStarts = new Set();
+    for (const i of starts)
+        realStarts.add(tupleKey(combo(i)));
+    for (const c of product)
+        if (!realStarts.has(tupleKey(c)))
+            return `The regions chart starts at ${words(c)}, where the model never starts.`;
+    for (const [i, r] of regions.entries())
+        for (const a of r.arrows)
+            if (a.condition.kind === "tuples")
+                return `In ${names[i]}, ${a.label} from ${unkey(a.from).join(" / ")} depends on the other regions in a way that one "and" or "or" condition cannot say.`;
+    const real = new Map();
+    for (const j of sorted) {
+        const before = combo(from[j]);
+        const after = combo(to[j]);
+        if (tupleKey(before) !== tupleKey(after))
+            addMove(real, { from: before, text: drawnLabels[j], to: after });
+    }
+    const combos = new Map();
+    for (const i of order) {
+        const c = combo(i);
+        combos.set(tupleKey(c), c);
+    }
+    const drawn = new Map();
+    for (const c of combos.values()) {
+        const enabled = new Map();
+        for (const [i, r] of regions.entries()) {
+            const rest = [];
+            for (let k = 0; k < c.length; k++)
+                if (k !== i)
+                    rest.push(c[k]);
+            for (const a of r.arrows)
+                if (a.from === c[i] && holds(a.condition, rest))
+                    append(enabled, a.label, { i, a });
+        }
+        for (const [text, list] of enabled) {
+            let groups = [];
+            if (together.has(text)) {
+                const byRegion = new Map();
+                for (const m of list)
+                    append(byRegion, m.i, m);
+                groups = [[]];
+                for (const opts of byRegion.values()) {
+                    const next = [];
+                    for (const g of groups)
+                        for (const m of opts)
+                            next.push([...g, m]);
+                    groups = next;
+                }
+            }
+            else
+                for (const m of list)
+                    groups.push([m]);
+            for (const group of groups) {
+                const to = [...c];
+                for (const { i, a } of group)
+                    to[i] = a.to;
+                addMove(drawn, { from: c, text, to });
+            }
+        }
+    }
+    for (const [k, extra] of drawn)
+        if (!real.has(k))
+            return `The regions chart lets ${words(extra.from)} go to ${words(extra.to)} by ${extra.text}, which the model never does.`;
+    for (const [k, missing] of real)
+        if (!drawn.has(k))
+            return `The model goes from ${words(missing.from)} to ${words(missing.to)} by ${missing.text}, which the regions chart cannot show.`;
+    return undefined;
+}