storm-lua-minify 0.2.0 → 0.9.0

package/dist/controlFlow.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeControlFlow = analyzeControlFlow;
+exports.childStatementBodies = childStatementBodies;
+const astWalk_1 = require("./astWalk");
+/**
+ * Builds a conservative intraprocedural CFG. Nested function bodies are separate execution units;
+ * closure construction never creates an execution edge into the nested body.
+ */
+function analyzeControlFlow(chunk, resolved, version = 0) {
+    const units = [];
+    const nodes = [];
+    const unknownEdges = [];
+    const pointByStatement = new WeakMap();
+    const nodeByStatement = new WeakMap();
+    const analyzedFunctions = new WeakSet();
+    let nextUnitId = 0;
+    let nextNodeId = 0;
+    const createNode = (unit, kind, statement, clauseIndex) => {
+        const created = {
+            id: nextNodeId++,
+            unit,
+            kind,
+            ...(statement ? { statement } : {}),
+            ...(clauseIndex === undefined ? {} : { clauseIndex }),
+            successors: [],
+            predecessors: [],
+        };
+        nodes.push(created);
+        if (statement && !nodeByStatement.has(statement)) {
+            nodeByStatement.set(statement, created);
+        }
+        return created;
+    };
+    const connect = (from, to, kind) => {
+        const edge = { from, to, kind };
+        from.successors.push(edge);
+        to.predecessors.push(edge);
+        if (kind === "unknown")
+            unknownEdges.push(edge);
+    };
+    const analyzeUnit = (body, kind, parent, owner) => {
+        const unit = {
+            id: nextUnitId++,
+            kind,
+            body,
+            ...(parent ? { parent } : {}),
+            ...(owner ? { owner } : {}),
+        };
+        units.push(unit);
+        const entry = createNode(unit, "entry");
+        const exit = createNode(unit, "exit");
+        const labels = new Map();
+        const pendingGotos = [];
+        const buildStatement = (statement, continuation, loopExit, loopBack) => {
+            switch (statement.type) {
+                case "ReturnStatement": {
+                    const current = createNode(unit, "statement", statement);
+                    connect(current, exit, "return");
+                    return current;
+                }
+                case "BreakStatement": {
+                    const current = createNode(unit, "statement", statement);
+                    connect(current, loopExit ?? exit, loopExit ? "break" : "unknown");
+                    return current;
+                }
+                case "GotoStatement": {
+                    const current = createNode(unit, "statement", statement);
+                    pendingGotos.push({
+                        node: current,
+                        target: resolved.symbolOf(statement.label),
+                    });
+                    return current;
+                }
+                case "LabelStatement": {
+                    const current = createNode(unit, "statement", statement);
+                    connect(current, continuation, "fallthrough");
+                    const symbol = resolved.symbolOf(statement.label);
+                    if (symbol)
+                        labels.set(symbol, current);
+                    return current;
+                }
+                case "IfStatement": {
+                    let falseTarget = continuation;
+                    for (let index = statement.clauses.length - 1; index >= 0; index--) {
+                        const clause = statement.clauses[index];
+                        const branchStart = buildBlock(clause.body, continuation, loopExit, loopBack);
+                        if (clause.type === "ElseClause") {
+                            falseTarget = branchStart;
+                            continue;
+                        }
+                        const condition = createNode(unit, "condition", statement, index);
+                        connect(condition, branchStart, "branch-true");
+                        connect(condition, falseTarget, "branch-false");
+                        falseTarget = condition;
+                    }
+                    nodeByStatement.set(statement, falseTarget);
+                    return falseTarget;
+                }
+                case "DoStatement": {
+                    const current = createNode(unit, "statement", statement);
+                    const bodyStart = buildBlock(statement.body, continuation, loopExit, loopBack);
+                    connect(current, bodyStart, "fallthrough");
+                    return current;
+                }
+                case "WhileStatement": {
+                    const header = createNode(unit, "condition", statement);
+                    const bodyStart = buildBlock(statement.body, header, continuation, header);
+                    connect(header, bodyStart, "loop-body");
+                    connect(header, continuation, "loop-exit");
+                    return header;
+                }
+                case "RepeatStatement": {
+                    const loopEntry = createNode(unit, "statement", statement);
+                    const condition = createNode(unit, "condition", statement, 0);
+                    const bodyStart = buildBlock(statement.body, condition, continuation, condition);
+                    connect(loopEntry, bodyStart, "loop-body");
+                    connect(condition, continuation, "loop-exit");
+                    connect(condition, bodyStart, "loop-back");
+                    return loopEntry;
+                }
+                case "ForNumericStatement":
+                case "ForGenericStatement": {
+                    const header = createNode(unit, "condition", statement);
+                    const bodyStart = buildBlock(statement.body, header, continuation, header);
+                    connect(header, bodyStart, "loop-body");
+                    connect(header, continuation, "loop-exit");
+                    return header;
+                }
+                case "LocalStatement":
+                case "AssignmentStatement":
+                case "CallStatement":
+                case "FunctionDeclaration": {
+                    const current = createNode(unit, "statement", statement);
+                    connect(current, continuation, continuation === exit
+                        ? "exit"
+                        : continuation === loopBack
+                            ? "loop-back"
+                            : "fallthrough");
+                    return current;
+                }
+            }
+        };
+        const buildBlock = (statements, continuation, loopExit, loopBack) => {
+            let next = continuation;
+            for (let index = statements.length - 1; index >= 0; index--) {
+                next = buildStatement(statements[index], next, loopExit, loopBack);
+            }
+            return next;
+        };
+        const first = buildBlock(body, exit);
+        connect(entry, first, first === exit ? "exit" : "entry");
+        pendingGotos.forEach(({ node, target: targetSymbol }) => {
+            const target = targetSymbol ? labels.get(targetSymbol) : undefined;
+            const known = target !== undefined;
+            connect(node, known ? target : exit, known ? "goto" : "unknown");
+        });
+        const indexPoints = (statements) => {
+            statements.forEach((statement, index) => {
+                const node = nodeByStatement.get(statement);
+                if (node)
+                    pointByStatement.set(statement, {
+                        unit,
+                        body: statements,
+                        index,
+                        statement,
+                        node,
+                    });
+                childBodiesOfStatement(statement).forEach(indexPoints);
+            });
+        };
+        indexPoints(body);
+        const nestedFunctions = [];
+        body.forEach((statement) => {
+            (0, astWalk_1.walkStatement)(statement, {
+                onFunction: (fn) => nestedFunctions.push(fn),
+            });
+        });
+        nestedFunctions.forEach((fn) => {
+            if (analyzedFunctions.has(fn))
+                return;
+            analyzedFunctions.add(fn);
+            analyzeUnit(fn.body, "function", unit, fn);
+        });
+    };
+    analyzeUnit(chunk.body, "chunk");
+    const dominators = computeDominators(units, nodes);
+    const nodeDominates = (first, last) => first.unit === last.unit && (dominators.get(last)?.has(first) ?? false);
+    return {
+        version,
+        complete: unknownEdges.length === 0,
+        units,
+        nodes,
+        unknownEdges,
+        pointOf: (statement) => pointByStatement.get(statement),
+        nodeOf: (statement) => nodeByStatement.get(statement),
+        dominates: (first, last) => {
+            const firstNode = nodeByStatement.get(first);
+            const lastNode = nodeByStatement.get(last);
+            return !!firstNode && !!lastNode && nodeDominates(firstNode, lastNode);
+        },
+        nodeDominates,
+    };
+}
+function computeDominators(units, nodes) {
+    const result = new Map();
+    units.forEach((unit) => {
+        const unitNodes = nodes.filter((node) => node.unit === unit);
+        const entry = unitNodes.find((node) => node.kind === "entry");
+        if (!entry)
+            return;
+        unitNodes.forEach((node) => result.set(node, new Set(node === entry ? [entry] : unitNodes)));
+        let changed = true;
+        while (changed) {
+            changed = false;
+            [...unitNodes].reverse().forEach((node) => {
+                if (node === entry)
+                    return;
+                const predecessors = node.predecessors.map((edge) => edge.from);
+                let next = new Set();
+                if (predecessors.length > 0) {
+                    next = new Set(result.get(predecessors[0]) ?? []);
+                    predecessors.slice(1).forEach((predecessor) => {
+                        const set = result.get(predecessor) ?? new Set();
+                        [...next].forEach((candidate) => {
+                            if (!set.has(candidate))
+                                next.delete(candidate);
+                        });
+                    });
+                }
+                next.add(node);
+                const previous = result.get(node) ?? new Set();
+                if (previous.size !== next.size ||
+                    [...previous].some((item) => !next.has(item))) {
+                    result.set(node, next);
+                    changed = true;
+                }
+            });
+        }
+    });
+    return result;
+}
+function childStatementBodies(body) {
+    return body.flatMap(childBodiesOfStatement);
+}
+function childBodiesOfStatement(statement) {
+    switch (statement.type) {
+        case "DoStatement":
+        case "WhileStatement":
+        case "RepeatStatement":
+        case "ForNumericStatement":
+        case "ForGenericStatement":
+            return [statement.body];
+        case "IfStatement":
+            return statement.clauses.map((clause) => clause.body);
+        case "FunctionDeclaration":
+        case "LocalStatement":
+        case "AssignmentStatement":
+        case "CallStatement":
+        case "ReturnStatement":
+        case "BreakStatement":
+        case "LabelStatement":
+        case "GotoStatement":
+            return [];
+    }
+}