@markw65/monkeyc-optimizer 1.1.11 → 1.1.12

package/README.md

@@ -703,3 +703,11 @@ Bug Fixes
   - Propagate any :typecheck annotations from inlined functions to their callers
   - Fix some issues keeping track of function calls used as arguments to inlined functions, that could result in bogus diagnostics.
   - Implement [Single Use Copy Propagation](https://github.com/markw65/monkeyc-optimizer/wiki/Local-variable-elimination#single-use-copy-propagation)
+
+### 1.1.12
+
+- Update to [@markw65/prettier-plugin-monkeyc@1.0.45](https://github.com/markw65/prettier-plugin-monkeyc#1045)
+  - fixes some bugs that could cause comments to go missing, resulting in an internal error from the formatter
+- Streamline some of the data structures used for `Minimise Locals` and `Single Copy Prop` to reduce memory use, and speed things up a little.
+- Fix a bug that could cause incorrect copy propagation in loops
+- Add support for update assignments in copy propagation (so that `var x = a; x += b; return x` goes to `return a + b`)

package/build/api.cjs

@@ -1507,9 +1507,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;
@@ -4955,74 +4956,43 @@ function addEquiv(ts, key, 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 = { ...keyVal };
+        keyVal.equivSet = new Set([key, equiv]);
+        ts.set(key, keyVal);
+    }
+    else {
+        keyVal.equivSet.add(equiv);
     }
     equivVal = { ...equivVal, equivSet: keyVal.equivSet };
-    keyVal.equivSet = { next: equiv };
-    ts.set(key, keyVal);
     ts.set(equiv, equivVal);
     return false;
 }
 function removeEquiv(ts, equiv) {
-    const equivVal = ts.get(equiv);
+    let 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;
+        ts.set(other, otherVal);
+    }
+    equivVal = { ...equivVal };
+    delete equivVal.equivSet;
+    ts.set(equiv, equivVal);
 }
 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;
+    assert(keys);
     return keys;
 }
 function intersectEquiv(ts1, ts2, k) {
@@ -5034,21 +5004,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) {
+        assert(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) {
@@ -5066,6 +5041,12 @@ 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 && key === Array.from(value.equivSet)[0]) {
+            const equivSet = new Set(value.equivSet);
+            equivSet.forEach((k) => clone.map.set(k, { ...clone.map.get(k), equivSet }));
+        }
+    });
     if (trackedMemberDecls) {
         clone.trackedMemberDecls = new Map();
         trackedMemberDecls.forEach((value, key) => {
@@ -5266,17 +5247,6 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
     });
     return changes;
 }
-function tsEquivs(state, key) {
-    const result = [];
-    let s = key;
-    do {
-        result.push(tsKey(s));
-        const next = state.get(s);
-        assert(next && next.equivSet);
-        s = next.equivSet.next;
-    } while (s !== key);
-    return `[(${result.join(", ")})]`;
-}
 function typeStateEntry(value, key) {
     return `${tsKey(key)} = ${display(value.curType)}`;
 }
@@ -5287,7 +5257,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) {
@@ -5565,15 +5537,11 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                  */
                 const v = blockState.map.get(decl);
                 if (v?.equivSet) {
-                    let s = decl;
-                    do {
+                    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)}`);
-                        }
+                        assert(next && next.equivSet?.has(s));
                         blockState.map.set(s, { ...next, curType: value });
-                        s = next.equivSet.next;
-                    } while (s !== decl);
+                    });
                 }
                 else {
                     blockState.map.set(decl, { ...v, curType: value });
@@ -5986,12 +5954,13 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                             }
                         });
                     }
+                    let calleeEffects;
                     curState.map.forEach((tsv, decl) => {
                         let type = tsv.curType;
-                        if (!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 */))) &&
+                            !some(decl, (d) => d.type === "VariableDeclarator" && !isLocal(d))) {
                             return;
                         }
                         if (modifiableDecl(decl, callees)) {
@@ -6007,9 +5976,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 || !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 ||
+                                        !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);
@@ -6020,15 +5994,10 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                                         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 });
                                 }
                             }
+                            clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
                         }
                     });
                     return true;
@@ -6147,22 +6116,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) {
@@ -6351,7 +6339,22 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                     }
                 }
             }));
-        traverseAst(func.node.body, null, (node) => {
+        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") {
@@ -6370,10 +6373,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 ${formatAstLongLines(node)} => ${formatAstLongLines(copyNode.right)}`);
+                        console.log(`copy-prop ${formatAstLongLines(node)} => ${formatAstLongLines(replacement)}`);
                     }
-                    return withLocDeep(copyNode.right, node, node, false);
+                    return withLocDeep(replacement, node, node, false);
                 }
                 else if (copyNode.type === "VariableDeclarator") {
                     assert(copyNode.init);
@@ -6715,18 +6726,18 @@ function couldBeObj(a, b) {
 
 
 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) {
     assert(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) {
@@ -6762,18 +6773,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);
             }
@@ -6786,17 +6789,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);
@@ -6860,7 +6861,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);
@@ -6881,25 +6882,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);

package/build/optimizer.cjs

@@ -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;
@@ -11183,18 +11184,18 @@ 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 +11231,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 +11247,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 +11319,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 +11340,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);
@@ -11596,74 +11583,43 @@ function addEquiv(ts, key, 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 = { ...keyVal };
+        keyVal.equivSet = new Set([key, equiv]);
+        ts.set(key, keyVal);
+    }
+    else {
+        keyVal.equivSet.add(equiv);
     }
     equivVal = { ...equivVal, equivSet: keyVal.equivSet };
-    keyVal.equivSet = { next: equiv };
-    ts.set(key, keyVal);
     ts.set(equiv, equivVal);
     return false;
 }
 function removeEquiv(ts, equiv) {
-    const equivVal = ts.get(equiv);
+    let 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;
+        ts.set(other, otherVal);
+    }
+    equivVal = { ...equivVal };
+    delete equivVal.equivSet;
+    ts.set(equiv, equivVal);
 }
 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 +11631,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 +11668,12 @@ 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 && key === Array.from(value.equivSet)[0]) {
+            const equivSet = new Set(value.equivSet);
+            equivSet.forEach((k) => clone.map.set(k, { ...clone.map.get(k), equivSet }));
+        }
+    });
     if (trackedMemberDecls) {
         clone.trackedMemberDecls = new Map();
         trackedMemberDecls.forEach((value, key) => {
@@ -11907,17 +11874,6 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
     });
     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 +11884,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) {
@@ -12206,15 +12164,11 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                  */
                 const v = blockState.map.get(decl);
                 if (v?.equivSet) {
-                    let s = decl;
-                    do {
+                    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)}`);
-                        }
+                        external_node_assert_namespaceObject(next && next.equivSet?.has(s));
                         blockState.map.set(s, { ...next, curType: value });
-                        s = next.equivSet.next;
-                    } while (s !== decl);
+                    });
                 }
                 else {
                     blockState.map.set(decl, { ...v, curType: value });
@@ -12627,12 +12581,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 +12603,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);
@@ -12661,15 +12621,10 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
                                         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 });
                                 }
                             }
+                            clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
                         }
                     });
                     return true;
@@ -12788,22 +12743,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 +12966,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 +13000,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);
@@ -16640,7 +16637,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 && 1676156189652 < opt_time) {
             return { hasTests, diagnostics: prevDiagnostics };
         }
     }
@@ -16667,7 +16664,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.12",
                 ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
             }))
                 .then(() => ({ hasTests, diagnostics }));

package/build/src/api.d.ts

@@ -26,7 +26,7 @@ export declare function findNamesInScope(declStack: StateNode[][], pattern: stri
     parent: StateNode;
     depth: number;
 }][];
-export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (ModuleStateNode | FunctionStateNode | ClassStateNode | TypedefStateNode | ProgramStateNode | VariableStateNode | import("./optimizer-types").BlockStateNode | EnumStateNode | mctree.EnumStringMember | mctree.Identifier | mctree.AsIdentifier)[];
+export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (ModuleStateNode | FunctionStateNode | ClassStateNode | TypedefStateNode | ProgramStateNode | mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | import("./optimizer-types").BlockStateNode | VariableStateNode | EnumStateNode)[];
 export declare function formatAstLongLines(node: mctree.Node): string;
 export declare function createDocumentationMap(functionDocumentation: {
     name: string;

package/build/src/type-flow/type-flow-util.d.ts

@@ -17,7 +17,7 @@ export declare function printBlockHeader(block: TypeFlowBlock): void;
 export declare function describeEvent(event: Event): string;
 export declare function printBlockEvents(block: TypeFlowBlock, extra?: (event: Event) => string): void;
 export declare function printBlockTrailer(block: TypeFlowBlock): void;
-export declare function findObjectDeclsByProperty(state: ProgramStateAnalysis, object: ExactOrUnion, next: mctree.DottedMemberExpression): readonly [null, null] | [StateNode[], StateNode[]];
+export declare function findObjectDeclsByProperty(state: ProgramStateAnalysis, object: ExactOrUnion, next: mctree.DottedMemberExpression): [StateNode[], StateNode[]] | readonly [null, null];
 export declare function refineObjectTypeByDecls(istate: InterpState, object: ExactOrUnion, trueDecls: StateNode[]): ExactOrUnion;
 export declare function findNextObjectType(istate: InterpState, trueDecls: StateNode[], next: mctree.DottedMemberExpression): import("./types").UnionType | import("./types").NumberType | import("./types").LongType | import("./types").FloatType | import("./types").DoubleType | import("./types").CharType | import("./types").StringType | import("./types").ArrayType | import("./types").DictionaryType | import("./types").MethodType | import("./types").ModuleType | import("./types").FunctionType | import("./types").ClassType | import("./types").ObjectType | import("./types").EnumType | import("./types").SymbolType | import("./types").TypedefType | null;
 export declare function resolveDottedMember(istate: InterpState, object: ExactOrUnion, next: mctree.DottedMemberExpression): {

package/build/src/type-flow/types.d.ts

@@ -26,7 +26,7 @@ export declare const enum TypeTag {
     Typedef = 262144,
     Any = 524287
 }
-export declare function typeTagName(tag: TypeTag): "Never" | "Null" | "False" | "True" | "Boolean" | "Number" | "Long" | "Float" | "Double" | "Decimal" | "Numeric" | "Char" | "String" | "Array" | "Dictionary" | "Method" | "Module" | "Function" | "Class" | "Object" | "Enum" | "Symbol" | "Typedef" | "Any";
+export declare function typeTagName(tag: TypeTag): "Number" | "Float" | "Double" | "Long" | "String" | "Char" | "Boolean" | "Null" | "Object" | "Symbol" | "Never" | "False" | "True" | "Decimal" | "Numeric" | "Array" | "Dictionary" | "Method" | "Module" | "Function" | "Class" | "Enum" | "Typedef" | "Any";
 export declare const LastTypeTag = TypeTag.Typedef;
 export declare const SingletonTypeTagsConst: number;
 export declare const UnionDataTypeTagsConst: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.1.11",
+  "version": "1.1.12",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -40,7 +40,7 @@
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.44"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.45"
   },
   "devDependencies": {
     "@types/chai": "^4.3.4",