@markw65/monkeyc-optimizer 1.1.8 → 1.1.9

package/README.md

@@ -666,3 +666,14 @@ Bug Fixes
   - Add support for comletion style lookups - find all the names available in the current context that fuzzy match a given string
   - Add helpers to read the function documentation from api.debug.xml
   - Add an option to visitReferences to only find a specific definition, rather than all definitions for that name in the current scope.
+
+### 1.1.9
+
+- Update to [@markw65/prettier-plugin-monkeyc@1.0.43](https://github.com/markw65/prettier-plugin-monkeyc#1043)
+
+- Bug fixes
+
+  - fix an interaction between inlining and removing unused local vars that could cause unlimited recursion leading to stack overflow
+
+- New optimizations
+  - Adds a `minimizeLocals` pass which runs after `sizeBasedPRE` and attempts to re-use local variables in order to reduce the total number, and hence reduce the stack size.

package/build/api.cjs

@@ -3483,7 +3483,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 break;
             case "BlockStatement":
             case "ForStatement":
-                if (locals.map && cleanupUnusedVars(state, node)) {
+                if (locals.map && cleanupUnusedVars(state, node) && !state.inlining) {
                     again = true;
                 }
                 break;
@@ -3971,7 +3971,9 @@ function pragmaChecker(state, ast, diagnostics) {
         if (node.start && node.start >= (comment.end || Infinity)) {
             const { kind, quote, needle } = matchers.shift();
             if (kind === "match") {
-                const haystack = formatAst(node).replace(/([\r\n]|\s)+/g, " ");
+                const haystack = formatAst(node)
+                    .replace(/([\r\n]|\s)+/g, " ")
+                    .replace(/\b\w+\s\/\*>(\w+)<\*\//g, "$1");
                 if (!matcher(quote, needle, haystack)) {
                     matcher(quote, needle, haystack);
                     diagnostic(state, comment, `Didn't find '${needle}' in '${haystack}'`, "ERROR");
@@ -3989,7 +3991,7 @@ function pragmaChecker(state, ast, diagnostics) {
                     }
                     if (a.end.line > b.end.line)
                         return 1;
-                    if (a.end.line === b.end.line && a.end.column >= b.end.column) {
+                    if (a.end.line === b.end.line && a.end.column > b.end.column) {
                         return 1;
                     }
                     return 0;
@@ -4044,8 +4046,10 @@ function pragmaChecker(state, ast, diagnostics) {
 /* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5101);
 /* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8180);
 /* harmony import */ var _function_info__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(819);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(6906);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _type_flow_minimize_locals__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(736);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_6__);
+
 
 
 
@@ -4150,6 +4154,7 @@ function sizeBasedPRE(state, func) {
         applyReplacements(func.node, nodeMap, declMap);
         func.node.body.body.unshift(variableDecl);
     }
+    minimizeLocals(state, func);
 }
 function buildPREGraph(state, func) {
     const result = buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
@@ -4800,7 +4805,7 @@ function applyReplacements(func, nodeMap, declMap) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "nK": () => (/* binding */ findObjectDeclsByProperty)
 /* harmony export */ });
-/* unused harmony exports missingNullWorkaround, buildTypeInfo, resolveDottedMember */
+/* unused harmony exports missingNullWorkaround, buildTypeInfo, buildConflictGraph, resolveDottedMember */
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
@@ -4836,10 +4841,20 @@ const logging = true;
 // To avoid over zealous optimizations, we don't optimize
 // away any Null checks for now.
 const missingNullWorkaround = true;
+function loggingEnabledFor(env, func) {
+    const pattern = process.env[env];
+    if (!pattern)
+        return false;
+    const match = pattern.match(/^\/(.*)\/(i?)$/);
+    if (match) {
+        return new RegExp(match[1], match[2]).test(func.fullName);
+    }
+    return pattern === func.fullName;
+}
 function buildTypeInfo(state, func, optimizeEquivalencies) {
     if (!func.node.body || !func.stack)
         return;
-    const logThisRun = logging && process.env["TYPEFLOW_FUNC"] === func.fullName;
+    const logThisRun = logging && loggingEnabledFor("TYPEFLOW_FUNC", func);
     while (true) {
         const { graph } = buildDataFlowGraph(state, func, () => false, false, true);
         if (optimizeEquivalencies &&
@@ -4850,9 +4865,18 @@ function buildTypeInfo(state, func, optimizeEquivalencies) {
              */
             continue;
         }
-        return propagateTypes({ ...state, stack: func.stack }, func, graph, optimizeEquivalencies, logThisRun);
+        return propagateTypes({ ...state, stack: func.stack }, func, graph, optimizeEquivalencies, logThisRun).istate;
     }
 }
+function buildConflictGraph(state, func) {
+    if (!func.node.body || !func.stack)
+        return;
+    const logThisRun = logging && loggingEnabledFor("CONFLICT_FUNC", func);
+    const { graph, identifiers } = buildDataFlowGraph(state, func, () => false, false, true);
+    const { nodeEquivs } = propagateTypes({ ...state, stack: func.stack }, func, graph, false, false);
+    const { locals, localConflicts } = findDeadStores(func, graph, nodeEquivs, logThisRun);
+    return { graph, localConflicts, locals, identifiers, logThisRun };
+}
 function addEquiv(ts, key, equiv) {
     if (key === equiv)
         return true;
@@ -5828,7 +5852,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
     }
     if (optimizeEquivalencies) {
         if (!nodeEquivs.size && !selfAssignments.size) {
-            return istate;
+            return { istate, nodeEquivs };
         }
         if (logThisRun) {
             if (selfAssignments.size) {
@@ -5928,7 +5952,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             return replacement;
         });
     }
-    return istate;
+    return { istate, nodeEquivs };
 }
 
 
@@ -6106,12 +6130,12 @@ function couldBeObj(a, b) {
 
 "use strict";
 /* unused harmony exports findDeadStores, eliminateDeadStores */
-/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6652);
-/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(333);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6817);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5101);
-/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8180);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
+/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5101);
+/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8180);
+/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(333);
 /* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(1638);
 
 
@@ -6119,12 +6143,13 @@ function couldBeObj(a, b) {
 
 
 
-function findDeadStores(graph, logThisRun) {
+function findDeadStores(func, graph, nodeEquivs, logThisRun) {
     const order = getPostOrder(graph);
     order.forEach((block, i) => {
         block.order = i;
     });
     const blockStates = [];
+    const nodeConflicts = nodeEquivs && new Map();
     const mergeStates = (to, from) => {
         return Array.from(to).reduce((changed, decl) => {
             if (!from.has(decl)) {
@@ -6135,11 +6160,13 @@ function findDeadStores(graph, logThisRun) {
         }, false);
     };
     const queue = new DataflowQueue();
-    const locals = new Set(order.flatMap((block) => block.events
+    const locals = new Set(order
+        .flatMap((block) => block.events
         ? block.events
             .filter((event) => event.type === "def" && declIsLocal(event.decl))
             .map((def) => def.decl)
-        : []));
+        : [])
+        .concat(func.node.params));
     const deadStores = new Set();
     order.forEach((block) => {
         if (!block.succs) {
@@ -6180,13 +6207,34 @@ function findDeadStores(graph, logThisRun) {
                         }
                         break;
                     case "def":
-                        if (isTypeStateKey(event.decl)) {
+                        if (isTypeStateKey(event.decl) &&
+                            (event.node.type !== "VariableDeclarator" || event.node.init)) {
                             if (curState.has(event.decl)) {
                                 deadStores.add(event.node);
                             }
                             else {
                                 deadStores.delete(event.node);
                             }
+                            if (nodeConflicts) {
+                                const conflicts = new Set(locals);
+                                curState.forEach((dead) => conflicts.delete(dead));
+                                if (event.rhs) {
+                                    conflicts.delete(event.rhs);
+                                    const equiv = event.node.type === "AssignmentExpression" &&
+                                        event.node.operator === "="
+                                        ? nodeEquivs.get(event.node.right)
+                                        : event.node.type === "VariableDeclarator" &&
+                                            event.node.init
+                                            ? nodeEquivs.get(event.node.init)
+                                            : null;
+                                    if (equiv) {
+                                        equiv.equiv.forEach((e) => isTypeStateKey(e) && conflicts.delete(e));
+                                        isTypeStateKey(equiv.decl) && conflicts.delete(equiv.decl);
+                                    }
+                                }
+                                conflicts.add(event.decl);
+                                nodeConflicts.set(event.node, conflicts);
+                            }
                             if ((event.node.type === "AssignmentExpression" &&
                                 event.node.operator === "=") ||
                                 (event.node.type === "VariableDeclarator" && event.node.init)) {
@@ -6231,10 +6279,27 @@ function findDeadStores(graph, logThisRun) {
             doMerge(top.bogopred);
         }
     }
-    return deadStores;
+    let localConflicts = null;
+    if (nodeConflicts) {
+        localConflicts = new Map();
+        const addConflicts = (conflict, conflicts) => {
+            let set = localConflicts.get(conflict);
+            if (set) {
+                conflicts.forEach((c) => c !== conflict && set.add(c));
+            }
+            else {
+                set = new Set(conflicts);
+                set.delete(conflict);
+                localConflicts.set(conflict, set);
+            }
+        };
+        nodeConflicts.forEach((conflicts) => conflicts.forEach((conflict) => addConflicts(conflict, conflicts)));
+        func.node.params.forEach((param, index, arr) => addConflicts(param, arr));
+    }
+    return { deadStores, locals, localConflicts };
 }
 function eliminateDeadStores(state, func, graph, logThisRun) {
-    const deadStores = findDeadStores(graph, logThisRun);
+    const { deadStores } = findDeadStores(func, graph, null, logThisRun);
     if (!deadStores.size)
         return false;
     if (logThisRun) {
@@ -8536,6 +8601,301 @@ function restrictByEquality(a, b) {
 }
 
 
+/***/ }),
+
+/***/ 736:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* unused harmony export minimizeLocals */
+/* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4143);
+/* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(node_assert__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5101);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6652);
+/* harmony import */ var _type_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4859);
+/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(1638);
+
+
+
+
+
+
+function minimizeLocals(state, func) {
+    const result = buildConflictGraph(state, func);
+    if (!result)
+        return;
+    const { graph, localConflicts, locals: localSet, identifiers, logThisRun, } = result;
+    if (!localConflicts)
+        return;
+    const colors = new Map();
+    const locals = Array.from(localSet)
+        .sort((a, b) => (localConflicts.get(a)?.size ?? 0) - (localConflicts.get(b)?.size ?? 0))
+        .filter((key) => key.type === "VariableDeclarator" ||
+        key.type === "Identifier" ||
+        key.type === "BinaryExpression");
+    const merge = [];
+    locals.forEach((local) => {
+        let inUse = 0n;
+        localConflicts.get(local)?.forEach((conflict) => {
+            const color = colors.get(conflict);
+            if (color != null) {
+                inUse |= 1n << BigInt(color);
+            }
+        });
+        let lowest = 0;
+        while (inUse & 1n) {
+            lowest++;
+            inUse >>= 1n;
+        }
+        colors.set(local, lowest);
+        if (!merge[lowest]) {
+            merge[lowest] = [local];
+        }
+        else {
+            merge[lowest].push(local);
+        }
+    });
+    const didMerge = merge.some((merged) => merged.length > 1);
+    if (didMerge !== (merge.length !== locals.length)) {
+        throw new Error("WTF?");
+    }
+    if (!didMerge)
+        return;
+    if (logThisRun) {
+        console.log(`>>> Merging locals in ${func.fullName}`);
+        merge.forEach((merged) => merged.length > 1 &&
+            console.log(` - merging ${merged.map((k) => tsKey(k)).join(" | ")}`));
+    }
+    const remap = new Map();
+    merge.forEach((merged) => {
+        if (merged.length === 1)
+            return;
+        const info = merged.reduce((cur, decl) => {
+            if (decl.type === "Identifier" || decl.type === "BinaryExpression") {
+                return {
+                    decl,
+                    stack: func.stack,
+                    depth: func.stack.length,
+                    name: variableDeclarationName(decl),
+                };
+            }
+            if (cur === null) {
+                return {
+                    decl,
+                    stack: decl.stack,
+                    depth: decl.stack.length,
+                    name: decl.name,
+                };
+            }
+            let depth = cur.depth < decl.stack.length ? cur.depth : decl.stack.length;
+            while (true) {
+                if (cur.stack[depth - 1].sn === decl.stack[depth - 1].sn) {
+                    break;
+                }
+                depth--;
+            }
+            if (cur.stack.length > decl.stack.length) {
+                return { decl, stack: decl.stack, depth, name: decl.name };
+            }
+            cur.depth = depth;
+            return cur;
+        }, null);
+        assert(info);
+        merged.forEach((decl) => remap.set(decl, info));
+        if (info.decl.type === "VariableDeclarator") {
+            let name = info.name;
+            if (locals.some((local) => local !== info.decl &&
+                local.type === "VariableDeclarator" &&
+                local.name === name)) {
+                // There's a variable in another scope with the same name, so
+                // produce a new one.
+                let i = 0;
+                do {
+                    name = `${info.decl.name}_${i++}`;
+                } while (identifiers.has(name));
+                identifiers.add(name);
+                info.name = name;
+            }
+            let depth = info.depth - 1;
+            let sn = info.stack[depth].sn;
+            while (true) {
+                assert(sn.type === "BlockStatement");
+                if (sn.node.type !== "ForStatement") {
+                    break;
+                }
+                sn = info.stack[--depth].sn;
+            }
+            const varDecl = {
+                type: "VariableDeclarator",
+                kind: "var",
+                id: { type: "Identifier", name },
+            };
+            if (sn.node.body.length &&
+                sn.node.body[0].type === "VariableDeclaration") {
+                sn.node.body[0].declarations.unshift(withLocDeep(varDecl, sn.node.body[0], false, true));
+            }
+            else {
+                sn.node.body.unshift(withLocDeep({
+                    type: "VariableDeclaration",
+                    declarations: [varDecl],
+                    kind: "var",
+                }, sn.node, false, true));
+            }
+        }
+    });
+    const order = getPostOrder(graph);
+    const nodeMap = new Map();
+    order.forEach((block) => block.events?.forEach((event) => {
+        if ((event.type !== "ref" && event.type !== "def") ||
+            !isTypeStateKey(event.decl) ||
+            !localSet.has(event.decl)) {
+            return;
+        }
+        const rep = remap.get(event.decl);
+        if (!rep)
+            return;
+        nodeMap.set(event.node, rep);
+    }));
+    traverseAst(func.node.body, null, (node) => {
+        const info = nodeMap.get(node);
+        switch (node.type) {
+            case "Identifier":
+                if (info && info.name !== node.name) {
+                    node.original = node.name;
+                    node.name = info.name;
+                }
+                return null;
+            case "AssignmentExpression":
+                if (info) {
+                    assert(node.left.type === "Identifier");
+                    if (node.right.type === "Identifier" &&
+                        node.right.name === info.name) {
+                        return withLoc({ type: "Literal", value: null, raw: "null" }, node, node);
+                    }
+                    if (node.left.name !== info.name) {
+                        node.left.original = node.left.name;
+                        node.left.name = info.name;
+                    }
+                    return null;
+                }
+                break;
+            case "ExpressionStatement":
+                if (node.expression.type === "Literal") {
+                    return false;
+                }
+                break;
+            case "UpdateExpression":
+                if (info) {
+                    assert(node.argument.type === "Identifier");
+                    if (node.argument.name !== info.name) {
+                        node.argument.original = node.argument.name;
+                        node.argument.name = info.name;
+                    }
+                    return null;
+                }
+                break;
+            case "VariableDeclarator":
+                if (info) {
+                    if (!node.init) {
+                        return false; // delete this entry
+                    }
+                    if (node.init.type === "Identifier" && node.init.name === info.name) {
+                        // this would create a self assignment, so just drop it
+                        return false;
+                    }
+                    // VariableDeclarations aren't allowed to have
+                    // AssignmentExpressions in them, but we'll fix that
+                    // below
+                    return withLoc({
+                        type: "AssignmentExpression",
+                        operator: "=",
+                        left: withLoc({
+                            type: "Identifier",
+                            name: info.name,
+                            original: variableDeclarationName(node.id),
+                        }, node.id, node.id),
+                        right: node.init,
+                    }, node, node);
+                }
+                break;
+            case "VariableDeclaration":
+                if (node.declarations.some((decl) => decl.type !== "VariableDeclarator")) {
+                    const results = [];
+                    node.declarations.forEach((decl) => {
+                        if (isExpression(decl)) {
+                            results.push(withLoc({ type: "ExpressionStatement", expression: decl }, decl, decl));
+                        }
+                        else if (decl.init) {
+                            results.push(withLoc({
+                                type: "ExpressionStatement",
+                                expression: withLoc({
+                                    type: "AssignmentExpression",
+                                    operator: "=",
+                                    left: withLoc({
+                                        type: "Identifier",
+                                        name: variableDeclarationName(decl.id),
+                                    }, decl.id, decl.id),
+                                    right: decl.init,
+                                }, decl, decl),
+                            }, decl, decl));
+                        }
+                    });
+                    node.declarations = node.declarations.filter((decl) => {
+                        if (decl.type === "VariableDeclarator") {
+                            delete decl.init;
+                            return true;
+                        }
+                        return false;
+                    });
+                    if (node.declarations.length) {
+                        withLocDeep(node, node, false);
+                        results.unshift(node);
+                    }
+                    // if this was the init of a ForStatement, this will
+                    // replace its init with a BlockStatement, so we have to
+                    // fix that below.
+                    return results;
+                }
+                break;
+            case "ForStatement":
+                if (node.init) {
+                    if (node.init.type === "BlockStatement") {
+                        const result = node.init;
+                        delete node.init;
+                        result.body.push(node);
+                        if (node.loc && result.loc) {
+                            // result has the range of the original VariableDeclaration
+                            // but now we're moving that ahead of the 'for', so to keep
+                            // things straight, we need to set the for's start to be
+                            // where result ended, and result's end to be where the for
+                            // ends (since that block now encloses the for)
+                            node.start = result.end;
+                            node.loc.start = result.loc.end;
+                            result.end = node.end;
+                            result.loc.end = node.loc.end;
+                        }
+                        return result;
+                    }
+                    if (node.init.type === "Literal") {
+                        delete node.init;
+                    }
+                }
+                break;
+            case "SequenceExpression":
+                if (node.expressions.some((e) => e.type === "Literal")) {
+                    node.expressions = node.expressions.filter((e) => e.type !== "Literal");
+                }
+                break;
+        }
+        assert(!info);
+        return null;
+    });
+    return;
+}
+
+
 /***/ }),
 
 /***/ 3687:
@@ -10917,6 +11277,14 @@ module.exports = require("@markw65/prettier-plugin-monkeyc");
 "use strict";
 module.exports = require("fs/promises");
 
+/***/ }),
+
+/***/ 4143:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:assert");
+
 /***/ })
 
 /******/ 	});