@markw65/monkeyc-optimizer 1.1.11 → 1.1.13

package/build/optimizer.cjs

@@ -6029,7 +6029,7 @@ function pragmaChecker(state, ast, diagnostics) {
             if (kind === "match") {
                 const haystack = (0,external_api_cjs_namespaceObject.formatAst)(node)
                     .replace(/([\r\n]|\s)+/g, " ")
-                    .replace(/\b\w+\s\/\*>(\w+)<\*\//g, "$1");
+                    .replace(/\b\w+\s\/\*>([\w.]+)<\*\//g, "$1");
                 if (!matcher(quote, needle, haystack)) {
                     matcher(quote, needle, haystack);
                     (0,external_api_cjs_namespaceObject.diagnostic)(state, comment, `Didn't find '${needle}' in '${haystack}'`, "ERROR");
@@ -10954,9 +10954,10 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
                             decl,
                             mayThrow,
                         };
-                        if (wantsAllRefs && node.operator === "=") {
-                            if (node.right.type === "Identifier" ||
-                                node.right.type === "MemberExpression") {
+                        if (wantsAllRefs) {
+                            if ((node.right.type === "Identifier" ||
+                                node.right.type === "MemberExpression") &&
+                                node.operator === "=") {
                                 const rhs = findDecl(node.right);
                                 if (rhs)
                                     def.rhs = rhs;
@@ -11182,19 +11183,20 @@ const external_node_assert_namespaceObject = require("node:assert");
 
 
 
+
 function cloneAnt(antMap) {
-    const ant = new Map();
-    antMap.forEach((s, k) => ant.set(k, new Set(s)));
-    return ant;
+    return new Map(antMap);
 }
 function addAnt(antMap, decl, node) {
     external_node_assert_namespaceObject(node.type === "Identifier");
     const ant = antMap.get(decl);
-    if (!ant) {
-        antMap.set(decl, new Set([node]));
+    if (ant === false || ant === node)
+        return;
+    if (ant === undefined) {
+        antMap.set(decl, node);
     }
     else {
-        ant.add(node);
+        antMap.set(decl, false);
     }
 }
 function cloneState(blockState) {
@@ -11230,18 +11232,10 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
             else {
                 changed = Array.from(to.anticipated).reduce((changed, [decl, toant]) => {
                     const fromant = from.anticipated.get(decl);
-                    if (!fromant) {
+                    if (toant !== fromant) {
                         to.anticipated.delete(decl);
                         changed = true;
                     }
-                    else {
-                        toant.forEach((node) => {
-                            if (!fromant.has(node)) {
-                                toant.delete(node);
-                                changed = true;
-                            }
-                        });
-                    }
                     return changed;
                 }, changed);
             }
@@ -11254,17 +11248,15 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
             else {
                 changed = Array.from(from.partiallyAnticipated).reduce((changed, [decl, fromant]) => {
                     const toant = to.partiallyAnticipated.get(decl);
-                    if (!toant) {
+                    if (toant === undefined) {
                         to.partiallyAnticipated.set(decl, fromant);
                         changed = true;
                     }
                     else {
-                        fromant.forEach((node) => {
-                            if (!toant.has(node)) {
-                                changed = true;
-                                toant.add(node);
-                            }
-                        });
+                        if (toant !== fromant) {
+                            changed = true;
+                            to.partiallyAnticipated.set(decl, false);
+                        }
                     }
                     return changed;
                 }, changed);
@@ -11328,7 +11320,7 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
                                 }
                                 addAnt(curState.partiallyAnticipated, event.decl, event.node);
                                 if (logThisRun) {
-                                    console.log(`  antrefs: ${curState.partiallyAnticipated.get(event.decl)?.size ?? 0} ${curState.anticipated.get(event.decl)?.size ?? 0}`);
+                                    console.log(`  antrefs: ${curState.partiallyAnticipated.get(event.decl) !== false} ${curState.anticipated.get(event.decl) !== false}`);
                                 }
                             }
                             curState.dead.delete(event.decl);
@@ -11349,25 +11341,21 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
                             }
                             else {
                                 deadStores.delete(event.node);
-                                if (assignNode &&
-                                    declIsLocal(event.decl) &&
-                                    curState.partiallyAnticipated) {
+                                copyPropStores.delete(event.node);
+                                if (declIsLocal(event.decl) && curState.partiallyAnticipated) {
                                     const pant = curState.partiallyAnticipated.get(event.decl);
-                                    if (pant && pant.size === 1) {
+                                    if (pant) {
                                         if (logThisRun) {
-                                            console.log(`  is copy-prop-candidate ${curState.anticipated?.get(event.decl)?.size ?? 0}`);
+                                            console.log(`  is copy-prop-candidate ${curState.anticipated?.get(event.decl) === pant}`);
                                         }
                                         copyPropStores.set(event.node, {
-                                            ref: Array.from(pant)[0],
-                                            ant: curState.anticipated?.get(event.decl)?.size === 1,
+                                            ref: pant,
+                                            ant: curState.anticipated?.get(event.decl) === pant,
                                         });
                                     }
                                     curState.partiallyAnticipated.delete(event.decl);
                                     curState.anticipated?.delete(event.decl);
                                 }
-                                else {
-                                    copyPropStores.delete(event.node);
-                                }
                             }
                             if (nodeConflicts) {
                                 const conflicts = new Set(locals);
@@ -11456,7 +11444,10 @@ function eliminateDeadStores(state, func, graph, logThisRun) {
             console.log(`${(0,external_api_cjs_namespaceObject.formatAst)(dead)} (${sourceLocation(dead.loc)})`));
     }
     let changes = false;
-    (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, null, (node, parent) => {
+    (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, null, (node) => {
+        const cleaned = variableCleanup(node);
+        if (cleaned !== null)
+            return cleaned;
         if (node.type === "ExpressionStatement" &&
             node.expression.type === "AssignmentExpression" &&
             deadStores.has(node.expression)) {
@@ -11478,40 +11469,17 @@ function eliminateDeadStores(state, func, graph, logThisRun) {
             changes = true;
             return { type: "Literal", value: null, raw: "null" };
         }
-        if (node.type === "VariableDeclaration") {
-            const result = [];
-            for (let i = 0; i < node.declarations.length; i++) {
-                const decl = node.declarations[i];
-                if (decl.init && deadStores.has(decl)) {
-                    const body = unused(state, decl.init);
-                    if (body.length) {
-                        if (!parent ||
-                            (parent.type !== "BlockStatement" && parent.type !== "SwitchCase")) {
-                            // Must be the init in a for statement. Fixing
-                            // it would be complicated, so just punt for now.
-                            break;
-                        }
-                        const newDeclaration = withLoc({ ...node }, node, decl.id);
-                        if (i + 1 < node.declarations.length) {
-                            newDeclaration.declarations = node.declarations.splice(0, i + 1);
-                            result.push(newDeclaration);
-                            withLoc(node, node.declarations[0], node);
-                            i = -1;
-                        }
-                        else {
-                            result.push(node);
-                        }
-                        result.push(...body);
-                    }
-                    changes = true;
-                    delete decl.init;
-                }
-            }
-            if (result.length) {
-                if (!result.includes(node)) {
-                    result.push(node);
+        if (node.type === "VariableDeclarator") {
+            const decl = node;
+            if (decl.init && deadStores.has(decl)) {
+                const body = unused(state, decl.init);
+                delete decl.init;
+                changes = true;
+                if (!body.length) {
+                    return null;
                 }
-                return result;
+                body.unshift(decl);
+                return body;
             }
         }
         return null;
@@ -11591,79 +11559,42 @@ function buildConflictGraph(state, func) {
 function addEquiv(ts, key, equiv) {
     if (key === equiv)
         return true;
-    let keyVal = ts.get(key);
-    let equivVal = ts.get(equiv);
+    const keyVal = ts.get(key);
+    const equivVal = ts.get(equiv);
     if (!keyVal || !equivVal)
         return false;
     if (equivVal.equivSet) {
-        if (keyVal.equivSet) {
-            // key is already a member of a set, see if
-            // equiv is part of it.
-            let s = keyVal.equivSet.next;
-            do {
-                if (s === equiv) {
-                    // these two are already equivalent
-                    return true;
-                }
-                const next = ts.get(s);
-                if (!next || !next.equivSet) {
-                    throw new Error(`Inconsistent equivSet for ${tsKey(key)}: missing value for ${tsKey(s)}`);
-                }
-                s = next.equivSet.next;
-            } while (s !== key);
+        if (equivVal.equivSet.has(key)) {
+            return true;
         }
         // equiv is already a member of a set. remove it
         removeEquiv(ts, equiv);
     }
     // equiv is not (or no longer) part of an equivSet
-    keyVal = { ...keyVal };
     if (!keyVal.equivSet) {
-        keyVal.equivSet = { next: key };
+        keyVal.equivSet = new Set([key, equiv]);
+    }
+    else {
+        keyVal.equivSet.add(equiv);
     }
-    equivVal = { ...equivVal, equivSet: keyVal.equivSet };
-    keyVal.equivSet = { next: equiv };
-    ts.set(key, keyVal);
-    ts.set(equiv, equivVal);
+    equivVal.equivSet = keyVal.equivSet;
     return false;
 }
 function removeEquiv(ts, equiv) {
     const equivVal = ts.get(equiv);
     if (!equivVal?.equivSet)
         return;
-    let s = equivVal.equivSet.next;
-    do {
-        const next = ts.get(s);
-        if (!next || !next.equivSet) {
-            throw new Error(`Inconsistent equivSet for ${tsKey(equiv)}: missing value for ${tsKey(s)}`);
-        }
-        if (next.equivSet.next === equiv) {
-            const { equivSet: _e, ...rest } = next;
-            if (equivVal.equivSet.next === s) {
-                // this is a pair. just kill both
-                ts.set(s, rest);
-            }
-            else {
-                ts.set(s, { ...rest, equivSet: equivVal.equivSet });
-            }
-            break;
-        }
-        s = next.equivSet.next;
-    } while (true);
-    const newVal = { ...equivVal };
-    delete newVal.equivSet;
-    ts.set(equiv, newVal);
+    equivVal.equivSet.delete(equiv);
+    if (equivVal.equivSet.size === 1) {
+        const other = Array.from(equivVal.equivSet)[0];
+        const otherVal = ts.get(other);
+        delete otherVal.equivSet;
+    }
+    delete equivVal.equivSet;
 }
 function getEquivSet(ts, k) {
-    const keys = new Set();
-    let s = k;
-    do {
-        const next = ts.get(s);
-        if (!next || !next.equivSet) {
-            throw new Error(`Inconsistent equivSet for ${tsKey(k)}: missing value for ${tsKey(s)}`);
-        }
-        keys.add(s);
-        s = next.equivSet.next;
-    } while (s !== k);
+    const keys = ts.get(k)?.equivSet;
+    external_node_assert_namespaceObject(keys);
     return keys;
 }
 function intersectEquiv(ts1, ts2, k) {
@@ -11675,21 +11606,26 @@ function intersectEquiv(ts1, ts2, k) {
         removeEquiv(ts1, k);
         return true;
     }
-    const keys = getEquivSet(ts2, k);
-    let ret = false;
-    let s = eq1.equivSet.next;
-    do {
-        const next = ts1.get(s);
-        if (!next || !next.equivSet) {
-            throw new Error(`Inconsistent equivSet for ${tsKey(k)}: missing value for ${tsKey(s)}`);
-        }
-        if (!keys.has(s)) {
-            ret = true;
-            removeEquiv(ts1, s);
+    let removed = null;
+    eq1.equivSet.forEach((key) => {
+        if (!eq2.equivSet.has(key)) {
+            eq1.equivSet.delete(key);
+            if (!removed) {
+                removed = new Set();
+            }
+            removed.add(key);
         }
-        s = next.equivSet.next;
-    } while (s !== k);
-    return ret;
+    });
+    if (eq1.equivSet.size === 1) {
+        external_node_assert_namespaceObject(eq1.equivSet.has(k));
+        delete eq1.equivSet;
+    }
+    if (removed) {
+        removed.forEach((k) => removed.size === 1
+            ? delete ts1.get(k).equivSet
+            : (ts1.get(k).equivSet = removed));
+    }
+    return false;
 }
 function clearAssocPaths(blockState, decl, v) {
     if (v.assocPaths?.size) {
@@ -11707,6 +11643,17 @@ function clearAssocPaths(blockState, decl, v) {
 function cloneTypeState(blockState) {
     const { map, trackedMemberDecls, liveCopyPropEvents, ...rest } = blockState;
     const clone = { map: new Map(map), ...rest };
+    clone.map.forEach((value, key) => {
+        if (value.equivSet) {
+            if (key === Array.from(value.equivSet)[0]) {
+                const equivSet = new Set(value.equivSet);
+                equivSet.forEach((k) => clone.map.set(k, { ...clone.map.get(k), equivSet }));
+            }
+        }
+        else {
+            clone.map.set(key, { ...value });
+        }
+    });
     if (trackedMemberDecls) {
         clone.trackedMemberDecls = new Map();
         trackedMemberDecls.forEach((value, key) => {
@@ -11741,12 +11688,9 @@ function addCopyPropEvent(blockState, item) {
     const liveCopyPropEvents = blockState.liveCopyPropEvents;
     const decl = item.event.decl;
     external_node_assert_namespaceObject(declIsLocal(decl));
-    let tov = blockState.map.get(decl);
+    const tov = blockState.map.get(decl);
     external_node_assert_namespaceObject(tov);
-    if (tov.copyPropItem !== item) {
-        tov = { ...tov, copyPropItem: item };
-        blockState.map.set(decl, tov);
-    }
+    tov.copyPropItem = item;
     item.contained.forEach((value, key) => {
         const decls = liveCopyPropEvents.get(key);
         if (!decls) {
@@ -11779,15 +11723,13 @@ function clearRelatedCopyPropEvents(blockState, decl, nodeCopyProp) {
     blockState.liveCopyPropEvents
         ?.get(decl)
         ?.forEach((cpDecl) => {
-        let value = blockState.map.get(cpDecl);
+        const value = blockState.map.get(cpDecl);
         external_node_assert_namespaceObject(value && value.copyPropItem);
         external_node_assert_namespaceObject(Array.from(value.copyPropItem.contained).some(([key]) => {
             return decl === key;
         }));
         copyPropFailed(blockState, value.copyPropItem, nodeCopyProp);
-        value = { ...value };
         delete value.copyPropItem;
-        blockState.map.set(cpDecl, value);
     });
 }
 function validateTypeState(curState) {
@@ -11830,11 +11772,9 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
         if (tov.equivSet) {
             if (intersectEquiv(to.map, from.map, k)) {
                 changes = true;
-                tov = to.map.get(k);
             }
         }
         if (tov.assocPaths) {
-            tov = { ...tov };
             if (!fromv.assocPaths) {
                 changes = true;
                 delete tov.assocPaths;
@@ -11857,7 +11797,6 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
                     delete tov.assocPaths;
                 }
             }
-            to.map.set(k, tov);
         }
         // if both from and to have copyPropEvents, we can only
         // keep it if they're the same event.
@@ -11875,10 +11814,8 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
                     }
                     nodeCopyProp.set(fromv.copyPropItem.event.node, false);
                 }
-                tov = { ...tov };
                 delete tov.copyPropItem;
                 changes = true;
-                to.map.set(k, tov);
             }
             else {
                 external_node_assert_namespaceObject(k === tov.copyPropItem.event.decl);
@@ -11889,7 +11826,7 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
             if (subtypeOf(fromv.curType, tov.curType))
                 return;
             if (subtypeOf(tov.curType, fromv.curType)) {
-                to.map.set(k, { ...tov, curType: fromv.curType });
+                tov.curType = fromv.curType;
                 changes = true;
                 return;
             }
@@ -11902,22 +11839,11 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
             if (wide)
                 result = wide;
         }
-        to.map.set(k, { ...tov, curType: result });
+        tov.curType = result;
         changes = true;
     });
     return changes;
 }
-function tsEquivs(state, key) {
-    const result = [];
-    let s = key;
-    do {
-        result.push(tsKey(s));
-        const next = state.get(s);
-        external_node_assert_namespaceObject(next && next.equivSet);
-        s = next.equivSet.next;
-    } while (s !== key);
-    return `[(${result.join(", ")})]`;
-}
 function typeStateEntry(value, key) {
     return `${tsKey(key)} = ${display(value.curType)}`;
 }
@@ -11928,7 +11854,9 @@ function printBlockState(block, state, indent = "") {
         return;
     }
     state.map.forEach((value, key) => {
-        console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet ? " " + tsEquivs(state.map, key) : ""}`);
+        console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet
+            ? " " + `[(${Array.from(value.equivSet).map(tsKey).join(", ")})]`
+            : ""}`);
     });
 }
 function updateAffected(blockState, objectType, baseDecl, assignedPath, affectedName, affected, assignedType) {
@@ -11936,7 +11864,6 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
         let droppedComponents = null;
         const entry = blockState.map.get(key);
         external_node_assert_namespaceObject(entry && entry.assocPaths);
-        let newEntry = entry;
         entry.assocPaths.forEach((path) => {
             if (key === baseDecl && path === assignedPath) {
                 return;
@@ -11955,12 +11882,9 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
                 });
                 if (pathItem === affectedName && couldBeShallow(type, objectType)) {
                     const newAssocKey = assocPath.map((av) => av.name ?? "*").join(".");
-                    if (newEntry === entry) {
-                        newEntry = { ...entry };
-                    }
                     if (newAssocKey !== path) {
-                        newEntry.assocPaths = new Set(newEntry.assocPaths);
-                        newEntry.assocPaths.delete(path);
+                        entry.assocPaths = new Set(entry.assocPaths);
+                        entry.assocPaths.delete(path);
                         // the "extra" path components will also have entries
                         // in blockState.trackedMemberDecls. Since they're gone
                         // from here, we (may) need to remove them from there
@@ -11972,8 +11896,7 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
                         }
                         break;
                     }
-                    const baseType = updateByAssocPath(assocPath, assignedType, true);
-                    newEntry.curType = baseType;
+                    entry.curType = updateByAssocPath(assocPath, assignedType, true);
                     break;
                 }
                 if (pathItem === "*") {
@@ -12003,14 +11926,11 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
                 }
             }
         });
-        if (newEntry !== entry) {
-            if (droppedComponents) {
-                newEntry.assocPaths.forEach((path) => path
-                    .split(".")
-                    .forEach((pathComponent) => droppedComponents.delete(pathComponent)));
-                droppedComponents.forEach((pathComponent) => blockState.trackedMemberDecls.get(pathComponent).delete(key));
-            }
-            blockState.map.set(key, newEntry);
+        if (droppedComponents) {
+            entry.assocPaths.forEach((path) => path
+                .split(".")
+                .forEach((pathComponent) => droppedComponents.delete(pathComponent)));
+            droppedComponents.forEach((pathComponent) => blockState.trackedMemberDecls.get(pathComponent).delete(key));
         }
     });
 }
@@ -12117,10 +12037,9 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
         const assocKey = assocValue.map((av) => av.name ?? "*").join(".");
         const newType = updateByAssocPath(assocValue, next, false);
         setStateEvent(blockState, decl.base, newType, newValue ? 1 /* UpdateKind.Inner */ : 0 /* UpdateKind.None */);
-        const tsv = { ...blockState.map.get(decl.base) };
+        const tsv = blockState.map.get(decl.base);
         tsv.assocPaths = new Set(tsv.assocPaths);
         tsv.assocPaths.add(assocKey);
-        blockState.map.set(decl.base, tsv);
         addTrackedMemberDecl(blockState, decl.base, assocKey);
         if (newValue) {
             const baseElem = assocValue[decl.path.length - 1];
@@ -12198,38 +12117,39 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                 // that foo is side-effect free, and accesses no globals.
                 clearRelatedCopyPropEvents(blockState, decl, nodeCopyProp);
             }
+            const v = blockState.map.get(decl);
+            if (!v) {
+                blockState.map.set(decl, { curType: value });
+                return;
+            }
             if (updateKind !== 2 /* UpdateKind.Reassign */) {
                 /*
                  * If we're not re-assigning, the equivalencies don't
                  * change, so this update must be applied to every
                  * element of the set
                  */
-                const v = blockState.map.get(decl);
-                if (v?.equivSet) {
-                    let s = decl;
-                    do {
+                if (v.equivSet) {
+                    v.equivSet.forEach((s) => {
                         const next = blockState.map.get(s);
-                        if (!next || !next.equivSet) {
-                            throw new Error(`Inconsistent equivSet for ${tsKey(decl)}: missing value for ${tsKey(s)}`);
-                        }
-                        blockState.map.set(s, { ...next, curType: value });
-                        s = next.equivSet.next;
-                    } while (s !== decl);
+                        external_node_assert_namespaceObject(next && next.equivSet?.has(s));
+                        next.curType = value;
+                    });
                 }
                 else {
-                    blockState.map.set(decl, { ...v, curType: value });
+                    v.curType = value;
                 }
             }
             else {
-                const v = blockState.map.get(decl);
                 removeEquiv(blockState.map, decl);
-                if (v?.assocPaths?.size) {
+                if (v.assocPaths?.size) {
                     clearAssocPaths(blockState, decl, v);
+                    delete v.assocPaths;
                 }
-                if (v?.copyPropItem) {
+                if (v.copyPropItem) {
                     copyPropFailed(blockState, v.copyPropItem, nodeCopyProp);
+                    delete v.copyPropItem;
                 }
-                blockState.map.set(decl, { curType: value });
+                v.curType = value;
             }
             return;
         }
@@ -12563,7 +12483,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                 break;
             }
             case "ref": {
-                let curEntry = getStateEntry(curState, event.decl);
+                const curEntry = getStateEntry(curState, event.decl);
                 typeMap.set(event.node, curEntry.curType);
                 nodeEquivs.delete(event.node);
                 if (curEntry.equivSet) {
@@ -12587,9 +12507,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                             nodeCopyProp.set(curEntry.copyPropItem.event.node, event.node);
                         }
                         clearCopyProp(curState, curEntry.copyPropItem);
-                        curEntry = { ...curEntry };
                         delete curEntry.copyPropItem;
-                        curState.map.set(event.decl, curEntry);
                     }
                     else if (declIsNonLocal(event.decl)) {
                         clearRelatedCopyPropEvents(curState, null, nodeCopyProp);
@@ -12627,12 +12545,13 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                             }
                         });
                     }
+                    let calleeEffects;
                     curState.map.forEach((tsv, decl) => {
                         let type = tsv.curType;
-                        if (!(0,external_util_cjs_namespaceObject.some)(decl, (d) => d.type === "VariableDeclarator" &&
-                            (d.node.kind === "var" ||
-                                // even a "const" could have its "inner" type altered
-                                (type.value != null && (type.type & 32768 /* TypeTag.Object */) !== 0)))) {
+                        if ((type.value == null ||
+                            !(type.type &
+                                (32768 /* TypeTag.Object */ | 512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */))) &&
+                            !(0,external_util_cjs_namespaceObject.some)(decl, (d) => d.type === "VariableDeclarator" && !(0,external_api_cjs_namespaceObject.isLocal)(d))) {
                             return;
                         }
                         if (modifiableDecl(decl, callees)) {
@@ -12648,9 +12567,14 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                             clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
                             curState.map.set(decl, { curType: typeConstraint(decl) });
                         }
-                        else if (type.value != null &&
-                            (!callees || !(0,external_util_cjs_namespaceObject.every)(callees, (callee) => callee.info === false))) {
-                            if (type.type & 32768 /* TypeTag.Object */) {
+                        else if (type.type &
+                            (32768 /* TypeTag.Object */ | 512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */) &&
+                            (calleeEffects == null
+                                ? (calleeEffects =
+                                    !callees ||
+                                        !(0,external_util_cjs_namespaceObject.every)(callees, (callee) => callee.info === false))
+                                : calleeEffects)) {
+                            if (type.value != null && type.type & 32768 /* TypeTag.Object */) {
                                 const odata = getObjectValue(tsv.curType);
                                 if (odata?.obj) {
                                     type = cloneType(type);
@@ -12658,18 +12582,12 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                                     setUnionComponent(type, 32768 /* TypeTag.Object */, newData);
                                     if (tsv.assocPaths) {
                                         clearAssocPaths(curState, decl, tsv);
-                                        tsv = { ...tsv };
                                         delete tsv.assocPaths;
                                     }
-                                    if (tsv.copyPropItem) {
-                                        copyPropFailed(curState, tsv.copyPropItem, nodeCopyProp);
-                                        tsv = { ...tsv };
-                                        delete tsv.copyPropItem;
-                                    }
-                                    clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
-                                    curState.map.set(decl, { ...tsv, curType: type });
+                                    tsv.curType = type;
                                 }
                             }
+                            clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
                         }
                     });
                     return true;
@@ -12691,10 +12609,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                         (event.node.type !== "AssignmentExpression" ||
                             event.node.operator !== "=")) {
                         copyPropFailed(curState, before.copyPropItem, nodeCopyProp);
-                        const v = { ...before };
-                        delete v.copyPropItem;
-                        external_node_assert_namespaceObject(isTypeStateKey(event.decl));
-                        curState.map.set(event.decl, v);
+                        delete before.copyPropItem;
                     }
                 }
                 const expr = event.node.type === "VariableDeclarator"
@@ -12788,22 +12703,41 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                                             decl.type === "BinaryExpression" ||
                                             decl.type === "Identifier"))) {
                                     const key = event.decl ?? null;
-                                    if (key &&
-                                        declIsLocal(key) &&
-                                        nodeCopyProp.has(event.node)) {
-                                        // we might have
-                                        //
-                                        //   var x = foo();
-                                        //   var y = x + 1;
-                                        //   bar();
-                                        //   return y;
-                                        //
-                                        // In that case, its ok to drop "x = foo()" and rewrite as y = foo() + 1"
-                                        // OR its ok to drop "y = x + 1" and rewrite as "return x + 1".
-                                        // But we can't do both, and rewrite as "bar(); return foo() + 1;"
-                                        // So just disable copy prop for *this* node. We'll re-run and have a
-                                        // second chance later.
-                                        return false;
+                                    if (key && declIsLocal(key)) {
+                                        if (nodeCopyProp.has(event.node)) {
+                                            // we might have
+                                            //
+                                            //   var x = foo();
+                                            //   var y = x + 1;
+                                            //   bar();
+                                            //   return y;
+                                            //
+                                            // In that case, its ok to drop "x = foo()" and rewrite as y = foo() + 1"
+                                            // OR its ok to drop "y = x + 1" and rewrite as "return x + 1".
+                                            // But we can't do both, and rewrite as "bar(); return foo() + 1;"
+                                            // So just disable copy prop for *this* node. We'll re-run and have a
+                                            // second chance later.
+                                            return false;
+                                        }
+                                        else if (event.node.type === "AssignmentExpression" &&
+                                            event.node.operator !== "=" &&
+                                            nodeCopyProp.has(event.node.left)) {
+                                            // If we're copy proping into the lhs of an update
+                                            // assignment, we're going to have to rewrite it.
+                                            // similar to the above, don't also do forward copy
+                                            // prop. eg
+                                            //
+                                            //  var x = a + b;
+                                            //  x += c;
+                                            //  return x;
+                                            //
+                                            // becomes
+                                            //
+                                            //  var x;
+                                            //  x = (a + b) + c;
+                                            //  return x; // <- dont propagate to here (yet), in case a+b has changed.
+                                            return false;
+                                        }
                                     }
                                     const item = contained.get(key);
                                     if (!item) {
@@ -12992,7 +12926,22 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                     }
                 }
             }));
-        (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, null, (node) => {
+        (0,external_api_cjs_namespaceObject.traverseAst)(func.node.body, (node) => {
+            if (node.type === "AssignmentExpression" &&
+                node.operator !== "=" &&
+                nodeCopyProp.has(node.left)) {
+                const left = cloneDeep(node.left);
+                const right = withLoc({
+                    type: "BinaryExpression",
+                    operator: node.operator.slice(0, -1),
+                    left: withLocDeep(node.left, node.right, false, true),
+                    right: node.right,
+                }, node.left, node.right);
+                node.operator = "=";
+                node.left = left;
+                node.right = right;
+            }
+        }, (node) => {
             const copyNode = nodeCopyProp.get(node);
             if (copyNode) {
                 if (node.type === "AssignmentExpression") {
@@ -13011,10 +12960,18 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                     return dup;
                 }
                 if (copyNode.type === "AssignmentExpression") {
+                    const replacement = copyNode.operator === "="
+                        ? copyNode.right
+                        : {
+                            type: "BinaryExpression",
+                            operator: copyNode.operator.slice(0, -1),
+                            left: copyNode.left,
+                            right: copyNode.right,
+                        };
                     if (logThisRun) {
-                        console.log(`copy-prop ${(0,external_api_cjs_namespaceObject.formatAstLongLines)(node)} => ${(0,external_api_cjs_namespaceObject.formatAstLongLines)(copyNode.right)}`);
+                        console.log(`copy-prop ${(0,external_api_cjs_namespaceObject.formatAstLongLines)(node)} => ${(0,external_api_cjs_namespaceObject.formatAstLongLines)(replacement)}`);
                     }
-                    return withLocDeep(copyNode.right, node, node, false);
+                    return withLocDeep(replacement, node, node, false);
                 }
                 else if (copyNode.type === "VariableDeclarator") {
                     external_node_assert_namespaceObject(copyNode.init);
@@ -13321,11 +13278,6 @@ function minimizeLocals(state, func) {
                     return null;
                 }
                 break;
-            case "ExpressionStatement":
-                if (node.expression.type === "Literal") {
-                    return false;
-                }
-                break;
             case "UpdateExpression":
                 if (info) {
                     external_node_assert_namespaceObject(node.argument.type === "Identifier");
@@ -13346,7 +13298,7 @@ function minimizeLocals(state, func) {
                     }
                     // VariableDeclarations aren't allowed to have
                     // AssignmentExpressions in them, but we'll fix that
-                    // below
+                    // via variableCleanup
                     return withLoc({
                         type: "AssignmentExpression",
                         operator: "=",
@@ -13359,79 +13311,92 @@ function minimizeLocals(state, func) {
                     }, 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: (0,external_api_cjs_namespaceObject.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);
+        }
+        external_node_assert_namespaceObject(!info);
+        return variableCleanup(node);
+    });
+    return;
+}
+function variableCleanup(node) {
+    switch (node.type) {
+        case "ExpressionStatement":
+            if (node.expression.type === "Literal") {
+                return false;
+            }
+            break;
+        case "VariableDeclaration":
+            if (node.declarations.some((decl) => decl.type !== "VariableDeclarator")) {
+                const results = [];
+                node.declarations.forEach((decl) => {
+                    if (isStatement(decl)) {
+                        results.push(decl);
                     }
-                    // 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;
+                    else 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: (0,external_api_cjs_namespaceObject.variableDeclarationName)(decl.id),
+                                }, decl.id, decl.id),
+                                right: decl.init,
+                            }, decl, decl),
+                        }, decl, decl));
                     }
-                    if (node.init.type === "Literal") {
-                        delete node.init;
+                });
+                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);
                 }
-                break;
-            case "SequenceExpression":
-                if (node.expressions.some((e) => e.type === "Literal")) {
-                    node.expressions = node.expressions.filter((e) => e.type !== "Literal");
+                // 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;
                 }
-                break;
-        }
-        external_node_assert_namespaceObject(!info);
-        return null;
-    });
-    return;
+                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;
+    }
+    return null;
 }
 
 ;// CONCATENATED MODULE: ./src/pre.ts
@@ -14184,6 +14149,199 @@ function applyReplacements(func, nodeMap, declMap) {
     });
 }
 
+;// CONCATENATED MODULE: ./src/type-flow/minimize-modules.ts
+
+
+
+function minimizeModules(ast, state) {
+    const { pre, post } = state;
+    try {
+        const replacementMap = new Map();
+        const conflictingNames = new Set();
+        state.pre = (node) => {
+            if (state.inType)
+                return null;
+            switch (node.type) {
+                case "ModuleDeclaration":
+                case "ClassDeclaration":
+                case "FunctionDeclaration":
+                    return ["body"];
+                case "Using":
+                    conflictingNames.add(node.as?.name ??
+                        (node.id.type === "Identifier"
+                            ? node.id.name
+                            : node.id.property.name));
+                    return [];
+                case "ImportModule":
+                    conflictingNames.add(node.id.type === "Identifier" ? node.id.name : node.id.property.name);
+                    return [];
+                case "Identifier":
+                case "MemberExpression": {
+                    let current = node;
+                    const parts = [];
+                    while (current.type === "MemberExpression" && !current.computed) {
+                        parts.unshift(current);
+                        current = current.object;
+                    }
+                    if (current.type !== "Identifier" &&
+                        current.type !== "ThisExpression") {
+                        break;
+                    }
+                    let toReplace = null;
+                    let module = null;
+                    let addImport = false;
+                    let [, results] = state.lookupValue(current, null);
+                    let i = 0;
+                    for (; results &&
+                        results.length === 1 &&
+                        results[0].results.length === 1 &&
+                        (results[0].results[0].type === "Program" ||
+                            results[0].results[0].type === "ClassDeclaration" ||
+                            results[0].results[0].type === "ModuleDeclaration"); i++) {
+                        if (current.type === "Identifier" &&
+                            results[0].results[0].type === "ModuleDeclaration" &&
+                            isImportCandidate(results[0].results[0])) {
+                            const directResults = i
+                                ? state.lookupValue(current, null)
+                                : results;
+                            if (directResults &&
+                                directResults.length === 1 &&
+                                directResults[0].results.length === 1 &&
+                                directResults[0].results[0] === results[0].results[0]) {
+                                // we would find the same thing if we just looked up
+                                // current directly.
+                                toReplace = (i ? parts[i - 1] : current);
+                                module = results[0].results[0];
+                                if ((0,external_api_cjs_namespaceObject.findUsingForNode)(state, state.stack, state.stack.length - 1, current) === directResults[0].results[0]) {
+                                    // we already find it via an import, so we don't need
+                                    // a new import.
+                                    addImport = false;
+                                }
+                                else {
+                                    addImport = true;
+                                }
+                            }
+                            else {
+                                toReplace = parts[i - 1];
+                                module = results[0].results[0];
+                                addImport = true;
+                            }
+                        }
+                        if (i === parts.length)
+                            break;
+                        current = parts[i].property;
+                        results = (0,external_api_cjs_namespaceObject.lookupNext)(state, results, "decls", current);
+                    }
+                    if (toReplace) {
+                        external_node_assert_namespaceObject(module);
+                        replacementMap.set(toReplace, { module, addImport });
+                    }
+                    else if (parts.length === 0) {
+                        external_node_assert_namespaceObject(node.type === "Identifier");
+                        conflictingNames.add(node.name);
+                    }
+                    else if (parts[0].object.type === "Identifier") {
+                        conflictingNames.add(parts[0].object.name);
+                    }
+                    return [];
+                }
+            }
+            return null;
+        };
+        (0,external_api_cjs_namespaceObject.collectNamespaces)(ast, state);
+        const mappedNames = new Map();
+        replacementMap.forEach((value, key) => {
+            let name;
+            if (value.addImport) {
+                name = mappedNames.get(value.module);
+                if (!name) {
+                    name = value.module.name;
+                    for (let i = 0; conflictingNames.has(name); i++) {
+                        name = `${value.module.name}_${i}`;
+                    }
+                    mappedNames.set(value.module, name);
+                    conflictingNames.add(name);
+                }
+            }
+            else {
+                name = key.type === "Identifier" ? key.name : key.property.name;
+            }
+            const original = (0,external_api_cjs_namespaceObject.formatAstLongLines)(key);
+            const repl = key;
+            repl.type = "Identifier";
+            repl.name = name;
+            if (name !== original) {
+                repl.original = original;
+            }
+            delete repl.property;
+            delete repl.object;
+            delete repl.computed;
+        });
+        mappedNames.forEach((name, module) => {
+            const id = makeScopedName(module.fullName.slice(2));
+            const as = name !== (id.type === "Identifier" ? id : id.property).name &&
+                makeIdentifier(name);
+            const using = withLocDeep(as ? { type: "Using", id, as } : { type: "Using", id }, ast, false, true);
+            ast.body.unshift(using);
+        });
+    }
+    finally {
+        state.pre = pre;
+        state.post = post;
+    }
+}
+/**
+ * There's a bug in garmin's runtime (although the compiler could
+ * work around it). See
+ *
+ *   https://forums.garmin.com/developer/connect-iq/i/bug-reports/referencing-an-imported-module-doesn-t-run-its-parent-s-init
+ *
+ * What this means is that if a module's parent isn't `globals`
+ * and it needs to be initialized, then we can't risk
+ * importing it, because the parent module might not get initialized
+ * in time.
+ */
+function isImportCandidate(module) {
+    if (module.fullName.startsWith("$.Toybox."))
+        return true;
+    if (module.fullName.startsWith("$.Rez."))
+        return false;
+    external_node_assert_namespaceObject(module.stack);
+    if (module.stack.length === 1)
+        return true;
+    return module.stack.every((elem) => {
+        if (!elem.sn.decls)
+            return false;
+        if (elem.sn.type === "Program")
+            return true;
+        if (elem.sn.type !== "ModuleDeclaration")
+            return false;
+        return Object.values(elem.sn.decls).every((decls) => decls.every((decl) => {
+            if (decl.type !== "VariableDeclarator")
+                return true;
+            if (!decl.node.init)
+                return true;
+            if (decl.node.init.type === "UnaryExpression" &&
+                decl.node.init.operator === ":") {
+                return true;
+            }
+            if (decl.node.init.type !== "Literal")
+                return false;
+            switch (typeof decl.node.init.value) {
+                case "boolean":
+                    return true;
+                case "bigint":
+                    return false;
+                case "number":
+                    return !/[dl]$/i.test(decl.node.init.raw);
+                case "object":
+                    return decl.node.init.value === null;
+            }
+            return false;
+        }));
+    });
+}
+
 ;// CONCATENATED MODULE: ./src/type-flow/optimize.ts
 
 
@@ -15034,6 +15192,7 @@ function cleanupUnusedVars(state, node) {
 
 
 
+
 /*
  * Map each name to the list of StateNodes that declare that
  * name (excluding Functions, which are already in allFunctions)
@@ -15621,32 +15780,30 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 break;
             case "Identifier": {
                 const map = topLocals().map;
-                if (map) {
-                    if ((0,external_api_cjs_namespaceObject.hasProperty)(map, node.name)) {
-                        const name = map[node.name];
-                        if (typeof name === "string") {
-                            renameIdentifier(node, name);
+                if ((0,external_api_cjs_namespaceObject.hasProperty)(map, node.name)) {
+                    const name = map[node.name];
+                    if (typeof name === "string") {
+                        renameIdentifier(node, name);
+                    }
+                    const [, results] = state.lookupValue(node);
+                    if (results) {
+                        if (results.length !== 1 || results[0].results.length !== 1) {
+                            throw new Error(`Local ${node.name} had multiple lookup results`);
                         }
-                        const [, results] = state.lookupValue(node);
-                        if (results) {
-                            if (results.length !== 1 || results[0].results.length !== 1) {
-                                throw new Error(`Local ${node.name} had multiple lookup results`);
-                            }
-                            const parent = results[0].parent;
-                            if (!parent) {
-                                throw new Error(`Local ${node.name} had no parent`);
-                            }
-                            const decl = results[0].results[0];
-                            if (parent.type === "FunctionDeclaration" ||
-                                decl.type !== "VariableDeclarator") {
-                                // we can't optimize away function or catch parameters
-                                return [];
-                            }
-                            if (parent.type !== "BlockStatement") {
-                                throw new Error(`Local ${node.name} was not declared at block scope(??)`);
-                            }
-                            decl.used = true;
+                        const parent = results[0].parent;
+                        if (!parent) {
+                            throw new Error(`Local ${node.name} had no parent`);
+                        }
+                        const decl = results[0].results[0];
+                        if (parent.type === "FunctionDeclaration" ||
+                            decl.type !== "VariableDeclarator") {
+                            // we can't optimize away function or catch parameters
+                            return [];
                         }
+                        if (parent.type !== "BlockStatement") {
+                            throw new Error(`Local ${node.name} was not declared at block scope(??)`);
+                        }
+                        decl.used = true;
                     }
                 }
                 return [];
@@ -15934,6 +16091,11 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
     state.nextExposed = {};
     delete state.pre;
     delete state.post;
+    if (state.config?.minimizeModules ?? true) {
+        Object.values(fnMap).forEach((f) => {
+            minimizeModules(f.ast, state);
+        });
+    }
     Object.values(state.allFunctions).forEach((fns) => fns.forEach((fn) => sizeBasedPRE(state, fn)));
     const cleanup = (node) => {
         switch (node.type) {
@@ -16579,6 +16741,7 @@ const configOptionsToCheck = [
     "propagateTypes",
     "singleUseCopyProp",
     "minimizeLocals",
+    "minimizeModules",
     "extensionVersion",
     "typeCheckLevel",
     "covarianceWarnings",
@@ -16640,7 +16803,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1676064117591 < opt_time) {
+        if (source_time < opt_time && 1676335488374 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -16667,7 +16830,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
                 hasTests,
                 diagnostics,
-                optimizerVersion: "1.1.11",
+                optimizerVersion: "1.1.13",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));