@markw65/monkeyc-optimizer 1.1.14 → 1.1.15

package/README.md

@@ -726,3 +726,14 @@ Bug Fixes
   - Remove stores to dead locals
   - Remove side-effect free code that produces an unused result
   - Optimize shift left by constant to multiply, since the bytecode is smaller (this seems to be a bug in the garmin tools; they consider shift left and shift right to have an 8-bit argument, but its always zero, and the simulator and devices treat it as a one byte shift instruction, followed by a one byte nop).
+
+### 1.1.15
+
+- Post build optimizer improvements
+
+  - Simplify LogicalExpressions. This generally saves 3 bytes per `&&` or `||`, and also makes them faster
+  - Adds a simple code sharing pass. If multiple code paths converge to the same point (or leave the function via return) and they end with the same sequence of bytecode, they're merged into one.
+  - Flips branch-true to branch-false or vice versa if the fall through block has multiple predecessors, and the target block has just one. This often leads to better control flow, reducing the number of "goto" bytecodes required.
+
+- Source to Source Optimizer improvements
+  - Adds an `Iterate Optimizer` option that causes the optimizer to keep re-running until it finds nothing to remove. Defaults to false.

package/build/api.cjs

@@ -3234,33 +3234,6 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
         return result;
     };
     const topLocals = () => state.localsStack[state.localsStack.length - 1];
-    /*
-     * Might this function be called from somewhere, including
-     * callbacks from the api (eg getSettingsView, etc).
-     */
-    const maybeCalled = (func) => {
-        if (!func.body) {
-            // this is an api.mir function. It can be called
-            return true;
-        }
-        if (hasProperty(state.exposed, func.id.name))
-            return true;
-        if (func.attrs &&
-            func.attrs.attributes &&
-            func.attrs.attributes.elements.some((attr) => {
-                if (attr.type !== "UnaryExpression")
-                    return false;
-                if (attr.argument.type !== "Identifier")
-                    return false;
-                return attr.argument.name === "test";
-            })) {
-            return true;
-        }
-        if (hasProperty(state.calledFunctions, func.id.name)) {
-            return (state.calledFunctions[func.id.name].find((f) => f === func) !== null);
-        }
-        return false;
-    };
     /*
      * Does elm (a class) have a maybeCalled function called name,
      * anywhere in its superClass chain.
@@ -3270,7 +3243,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
             elm.superClass.some((sc) => (hasProperty(sc.decls, name) &&
                 sc.decls[name].some((f) => isStateNode(f) &&
                     f.type === "FunctionDeclaration" &&
-                    maybeCalled(f.node))) ||
+                    maybeCalled(state, f.node))) ||
                 (sc.superClass && checkInherited(sc, name))));
     const renamer = (idnode) => {
         const ident = idnode.type === "Identifier" ? idnode : idnode.left;
@@ -3471,7 +3444,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     }
                     istate = is;
                 }
-                if (parent.type === "ClassDeclaration" && !maybeCalled(node)) {
+                if (parent.type === "ClassDeclaration" && !maybeCalled(state, node)) {
                     let used = false;
                     if (node.id.name === "initialize") {
                         used = true;
@@ -3673,15 +3646,31 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
     Object.values(fnMap).forEach((f) => {
         collectNamespaces(f.ast, state);
     });
-    state.usedByName = {};
-    state.calledFunctions = {};
-    state.exposed = state.nextExposed;
-    state.nextExposed = {};
-    Object.values(fnMap).forEach((f) => {
-        collectNamespaces(f.ast, state);
-    });
-    state.exposed = state.nextExposed;
-    state.nextExposed = {};
+    const cleanupAll = () => Object.values(fnMap).reduce((changes, f) => {
+        traverseAst(f.ast, undefined, (node) => {
+            const ret = cleanup(state, node, f.ast);
+            if (ret === false) {
+                changes = true;
+                state.removeNodeComments(node, f.ast);
+            }
+            else if (ret) {
+                changes = true;
+            }
+            return ret;
+        });
+        return changes;
+    }, false);
+    do {
+        state.usedByName = {};
+        state.calledFunctions = {};
+        state.exposed = state.nextExposed;
+        state.nextExposed = {};
+        Object.values(fnMap).forEach((f) => {
+            collectNamespaces(f.ast, state);
+        });
+        state.exposed = state.nextExposed;
+        state.nextExposed = {};
+    } while (cleanupAll() && state.config?.iterateOptimizer);
     delete state.pre;
     delete state.post;
     if (state.config?.minimizeModules ?? true) {
@@ -3690,108 +3679,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
         });
     }
     Object.values(state.allFunctions).forEach((fns) => fns.forEach((fn) => sizeBasedPRE(state, fn)));
-    const cleanup = (node) => {
-        switch (node.type) {
-            case "ThisExpression":
-                node.text = "self";
-                break;
-            case "EnumStringBody":
-                if (node.members.every((m) => {
-                    const name = "name" in m ? m.name : m.id.name;
-                    return (hasProperty(state.index, name) &&
-                        !hasProperty(state.exposed, name) &&
-                        !hasProperty(state.usedByName, name));
-                })) {
-                    node.enumType = [
-                        ...new Set(node.members.map((m) => {
-                            if (!("init" in m))
-                                return "Number";
-                            const [node, type] = getNodeValue(m.init);
-                            if (!node) {
-                                throw new Error("Failed to get type for eliminated enum");
-                            }
-                            return type;
-                        })),
-                    ].join(" or ");
-                    node.members.splice(0);
-                }
-                break;
-            case "EnumDeclaration":
-                if (!node.body.members.length) {
-                    if (!node.id)
-                        return false;
-                    if (!node.body.enumType) {
-                        throw new Error("Missing enumType on optimized enum");
-                    }
-                    return {
-                        type: "TypedefDeclaration",
-                        id: node.id,
-                        ts: {
-                            type: "UnaryExpression",
-                            argument: {
-                                type: "TypeSpecList",
-                                ts: [
-                                    node.body.enumType,
-                                ],
-                            },
-                            prefix: true,
-                            operator: " as",
-                        },
-                    };
-                }
-                break;
-            case "VariableDeclaration": {
-                node.declarations = node.declarations.filter((d) => {
-                    const name = variableDeclarationName(d.id);
-                    return (!hasProperty(state.index, name) ||
-                        hasProperty(state.exposed, name) ||
-                        hasProperty(state.usedByName, name));
-                });
-                if (!node.declarations.length) {
-                    return false;
-                }
-                break;
-            }
-            case "ClassElement":
-                if (!node.item) {
-                    return false;
-                }
-                break;
-            case "FunctionDeclaration":
-                if (!maybeCalled(node)) {
-                    if (node.attrs &&
-                        node.attrs.attributes &&
-                        node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" && attr.argument.name === "keep")) {
-                        break;
-                    }
-                    return false;
-                }
-                break;
-            case "ClassDeclaration":
-            case "ModuleDeclaration":
-                // none of the attributes means anything on classes and
-                // modules, and the new compiler complains about some
-                // of them. Just drop them all.
-                if (node.attrs && node.attrs.access) {
-                    if (node.attrs.attributes) {
-                        delete node.attrs.access;
-                    }
-                    else {
-                        delete node.attrs;
-                    }
-                }
-        }
-        return null;
-    };
-    Object.entries(fnMap).forEach(([, f]) => {
-        traverseAst(f.ast, undefined, (node) => {
-            const ret = cleanup(node);
-            if (ret === false) {
-                state.removeNodeComments(node, f.ast);
-            }
-            return ret;
-        });
-    });
+    cleanupAll();
     config.checkCompilerLookupRules = checkLookupRules;
     reportMissingSymbols(state, config);
     if (state.inlineDiagnostics) {
@@ -3817,6 +3705,129 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
     });
     return state.diagnostics;
 }
+/*
+ * Might this function be called from somewhere, including
+ * callbacks from the api (eg getSettingsView, etc).
+ */
+function maybeCalled(state, func) {
+    if (!func.body) {
+        // this is an api.mir function. It can be called
+        return true;
+    }
+    if (hasProperty(state.exposed, func.id.name))
+        return true;
+    if (func.attrs &&
+        func.attrs.attributes &&
+        func.attrs.attributes.elements.some((attr) => {
+            if (attr.type !== "UnaryExpression")
+                return false;
+            if (attr.argument.type !== "Identifier")
+                return false;
+            return attr.argument.name === "test";
+        })) {
+        return true;
+    }
+    if (hasProperty(state.calledFunctions, func.id.name)) {
+        return state.calledFunctions[func.id.name].find((f) => f === func) !== null;
+    }
+    return false;
+}
+function cleanup(state, node, ast) {
+    switch (node.type) {
+        case "ThisExpression":
+            node.text = "self";
+            break;
+        case "EnumStringBody":
+            if (node.members.every((m) => {
+                const name = "name" in m ? m.name : m.id.name;
+                return (hasProperty(state.index, name) &&
+                    !hasProperty(state.exposed, name) &&
+                    !hasProperty(state.usedByName, name));
+            })) {
+                node.enumType = [
+                    ...new Set(node.members.map((m) => {
+                        if (!("init" in m))
+                            return "Number";
+                        const [node, type] = getNodeValue(m.init);
+                        if (!node) {
+                            throw new Error("Failed to get type for eliminated enum");
+                        }
+                        return type;
+                    })),
+                ].join(" or ");
+                node.members.splice(0);
+            }
+            break;
+        case "EnumDeclaration":
+            if (!node.body.members.length) {
+                if (!node.id)
+                    return false;
+                if (!node.body.enumType) {
+                    throw new Error("Missing enumType on optimized enum");
+                }
+                state.removeNodeComments(node, ast);
+                return withLocDeep({
+                    type: "TypedefDeclaration",
+                    id: node.id,
+                    ts: {
+                        type: "UnaryExpression",
+                        argument: {
+                            type: "TypeSpecList",
+                            ts: [
+                                node.body.enumType,
+                            ],
+                        },
+                        prefix: true,
+                        operator: " as",
+                    },
+                }, node, node);
+            }
+            break;
+        case "VariableDeclarator": {
+            const name = variableDeclarationName(node.id);
+            return !hasProperty(state.index, name) ||
+                hasProperty(state.exposed, name) ||
+                hasProperty(state.usedByName, name)
+                ? null
+                : false;
+        }
+        case "VariableDeclaration": {
+            if (!node.declarations.length) {
+                return false;
+            }
+            break;
+        }
+        case "ClassElement":
+            if (!node.item) {
+                return false;
+            }
+            break;
+        case "FunctionDeclaration":
+            if (!maybeCalled(state, node)) {
+                if (node.attrs &&
+                    node.attrs.attributes &&
+                    node.attrs.attributes.elements.some((attr) => attr.type === "UnaryExpression" && attr.argument.name === "keep")) {
+                    break;
+                }
+                return false;
+            }
+            break;
+        case "ClassDeclaration":
+        case "ModuleDeclaration":
+            // none of the attributes means anything on classes and
+            // modules, and the new compiler complains about some
+            // of them. Just drop them all.
+            if (node.attrs && node.attrs.access) {
+                if (node.attrs.attributes) {
+                    delete node.attrs.access;
+                }
+                else {
+                    delete node.attrs;
+                }
+            }
+    }
+    return null;
+}
 function optimizeCall(istate, node, context) {
     const state = istate.state;
     const [name, results] = state.lookupNonlocal(node.callee);
@@ -12356,6 +12367,14 @@ module.exports = require("./api.cjs");
 
 /***/ }),
 
+/***/ 7168:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("./sdk-util.cjs");
+
+/***/ }),
+
 /***/ 6906:
 /***/ ((module) => {
 
@@ -12515,8 +12534,8 @@ var negative_fixups = __webpack_require__(4499);
 var optimizer_types = __webpack_require__(9697);
 // EXTERNAL MODULE: external "./api.cjs"
 var external_api_cjs_ = __webpack_require__(6817);
-;// CONCATENATED MODULE: external "./sdk-util.cjs"
-const external_sdk_util_cjs_namespaceObject = require("./sdk-util.cjs");
+// EXTERNAL MODULE: external "./sdk-util.cjs"
+var external_sdk_util_cjs_ = __webpack_require__(7168);
 ;// CONCATENATED MODULE: ./src/resources.ts
 
 
@@ -12568,7 +12587,7 @@ function visit_resources(elements, parent, v) {
                         error(e);
                         break;
                     }
-                    visit_resources(external_sdk_util_cjs_namespaceObject.xmlUtil.elementKids(e), e, visitor);
+                    visit_resources(external_sdk_util_cjs_.xmlUtil.elementKids(e), e, visitor);
                     break;
                 // These are the resources themselves. Some can occur at top level; most
                 // are restricted to <resources> or one or more of the specific lists above
@@ -12713,7 +12732,7 @@ function add_resources_to_ast(state, ast, resources, manifestXML) {
         rez.body.body.push(hiddenRez);
         if (barrel === "" &&
             manifestXML &&
-            manifestXML.body instanceof external_sdk_util_cjs_namespaceObject.xmlUtil.Nodes) {
+            manifestXML.body instanceof external_sdk_util_cjs_.xmlUtil.Nodes) {
             manifestXML.body
                 .children("iq:application")
                 .elements.forEach((e) => add_one_resource(state, manifestXML, rez, e));
@@ -12856,7 +12875,7 @@ function visit_resource_refs(state, doc, e) {
                 return;
         }
     };
-    external_sdk_util_cjs_namespaceObject.xmlUtil.visit_xml([e], {
+    external_sdk_util_cjs_.xmlUtil.visit_xml([e], {
         pre(node) {
             if (node.type !== "element")
                 return false;
@@ -13301,7 +13320,7 @@ function checkCompilerVersion(version, sdkVer) {
 async function getApiMapping(state, resourcesMap, manifestXML) {
     // get the path to the currently active sdk
     const parser = (prettier_plugin_monkeyc_default()).parsers.monkeyc;
-    const sdk = await (0,external_sdk_util_cjs_namespaceObject.getSdkPath)();
+    const sdk = await (0,external_sdk_util_cjs_.getSdkPath)();
     if (state) {
         state.sdk = sdk;
         const match = state.sdk?.match(/-(\d+\.\d+\.\d+)/);