@markw65/monkeyc-optimizer 1.1.10 → 1.1.11

package/build/api.cjs

@@ -619,7 +619,7 @@ class LocalState {
         this.unreachable = true;
     }
 }
-function buildReducedGraph(state, func, notice) {
+function buildReducedGraph(state, func, refsForUpdate, notice) {
     const { stack, pre, post } = state;
     try {
         const localState = new LocalState(func.node);
@@ -627,8 +627,11 @@ function buildReducedGraph(state, func, notice) {
         state.stack = [...func.stack];
         const stmtStack = [func.node];
         const testStack = [{ node: func.node }];
+        const allEvents = [];
+        const eventsStack = [];
         let tryActive = 0;
         state.pre = (node) => {
+            eventsStack.push(allEvents.length);
             if (state.inType || localState.unreachable) {
                 return [];
             }
@@ -954,6 +957,12 @@ function buildReducedGraph(state, func, notice) {
                     }
                     return [];
                 case "AssignmentExpression":
+                    if (refsForUpdate && node.operator !== "=") {
+                        // if its an update, we need to see a "ref"
+                        // of the lhs, then whatever happens on the rhs,
+                        // and then the assignment itself
+                        return null;
+                    }
                     if (node.left.type === "MemberExpression") {
                         state.traverse(node.left.object);
                         if (node.left.computed) {
@@ -983,6 +992,7 @@ function buildReducedGraph(state, func, notice) {
             return null;
         };
         const addEvent = (block, event) => {
+            allEvents.push(event);
             if (!block.events) {
                 block.events = [event];
             }
@@ -991,11 +1001,13 @@ function buildReducedGraph(state, func, notice) {
             }
         };
         state.post = (node) => {
+            const eventIndex = eventsStack.pop();
+            const getContainedEvents = () => allEvents.slice(eventIndex);
             const curStmt = stmtStack[stmtStack.length - 1];
             const topTest = testStack[testStack.length - 1];
             if (!state.inType) {
                 const throws = tryActive > 0 && mayThrow(node);
-                const events = notice(node, curStmt, throws);
+                const events = notice(node, curStmt, throws, getContainedEvents);
                 if (throws) {
                     if (!events) {
                         throw new Error("mayThrow expression in try/catch must generate an event");
@@ -1042,7 +1054,7 @@ function buildReducedGraph(state, func, notice) {
                             throw new Error("Internal error: Unexpected successor edges");
                         }
                         localState.addEdge(localState.curBlock, topTest.false);
-                        const event = notice(node, curStmt, 1);
+                        const event = notice(node, curStmt, 1, getContainedEvents);
                         if (event) {
                             if (Array.isArray(event)) {
                                 throw new Error(`Unexpected array of flw events`);
@@ -1183,8 +1195,10 @@ function getPreOrder(head) {
 /* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6652);
 /* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5101);
 /* harmony import */ var _function_info__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(819);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(6906);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _type_flow_type_flow_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(1638);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_6__);
+
 
 
 
@@ -1349,7 +1363,7 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
         };
     return {
         identifiers,
-        graph: buildReducedGraph(state, func, (node, stmt, mayThrow) => {
+        graph: buildReducedGraph(state, func, wantsAllRefs, (node, stmt, mayThrow, getContainedEvents) => {
             if (mayThrow === 1) {
                 return wantsAllRefs ? getFlowEvent(node, stmt, findDecl) : null;
             }
@@ -1473,6 +1487,12 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
                             if (rhs)
                                 def.rhs = rhs;
                         }
+                        if (declIsLocal(decl)) {
+                            const contained = getContainedEvents().filter((e) => e.type === "ref" || e.type === "mod");
+                            if (contained.length) {
+                                def.containedEvents = contained;
+                            }
+                        }
                         return def;
                     }
                     break;
@@ -1487,13 +1507,19 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
                             decl,
                             mayThrow,
                         };
-                        if (wantsAllRefs &&
-                            node.operator === "=" &&
-                            (node.right.type === "Identifier" ||
-                                node.right.type === "MemberExpression")) {
-                            const rhs = findDecl(node.right);
-                            if (rhs)
-                                def.rhs = rhs;
+                        if (wantsAllRefs && node.operator === "=") {
+                            if (node.right.type === "Identifier" ||
+                                node.right.type === "MemberExpression") {
+                                const rhs = findDecl(node.right);
+                                if (rhs)
+                                    def.rhs = rhs;
+                            }
+                            if (declIsLocal(decl)) {
+                                const contained = getContainedEvents().filter((e) => e.type === "ref" || e.type === "mod");
+                                if (contained.length) {
+                                    def.containedEvents = contained;
+                                }
+                            }
                         }
                         return def;
                     }
@@ -1546,6 +1572,12 @@ function buildDataFlowGraph(state, func, wantsLiteral, trackInsertionPoints, wan
                                     mod.calleeObj = calleeDecl.base;
                                 }
                             }
+                            else if (node.callee.type === "MemberExpression") {
+                                const calleeObj = findDecl(node.callee.object);
+                                if (calleeObj) {
+                                    mod.calleeObj = calleeObj;
+                                }
+                            }
                             return mod;
                         }
                     }
@@ -1846,7 +1878,7 @@ function findCalleesByNode(state, callee) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* unused harmony exports inlinableSubExpression, shouldInline, unused, inlineDiagnostic, inlineFunction, applyTypeIfNeeded */
+/* unused harmony exports inlinableSubExpression, inlineRequested, shouldInline, unused, inlineDiagnostic, inlineFunction, applyTypeIfNeeded */
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
@@ -2533,16 +2565,18 @@ function updateLocationForInline(node, original, context, func) {
         throw new Error("Internal error: Inlined call had no location info");
     }
     traverseAst(node, (node) => {
-        if (node.loc &&
-            (node.loc.source !== loc.source ||
-                node.loc.start.offset > loc.end.offset ||
-                node.loc.end.offset <= loc.start.offset)) {
-            if (!node.origins) {
-                node.origins = [];
+        if (!node.loc ||
+            node.loc.source !== loc.source ||
+            node.loc.start.offset > loc.end.offset ||
+            node.loc.end.offset <= loc.start.offset) {
+            if (node.loc) {
+                if (!node.origins) {
+                    node.origins = [];
+                }
+                node.origins.unshift({ loc: node.loc, func: func.fullName });
             }
-            node.origins.unshift({ loc: node.loc, func: func.fullName });
+            withLoc(node, context, context === original ? context : false);
         }
-        withLoc(node, context, context === original ? context : false);
     });
     return node;
 }
@@ -2570,8 +2604,8 @@ function inlineFunction(state, func, call, context) {
     const ret = inlineFunctionHelper(state, func, call, context);
     if (!ret)
         return ret;
-    const typecheckFalse = func.node.attrs?.attributes?.elements.find((attr) => isTypecheckArg(attr, false));
-    if (!typecheckFalse) {
+    const typecheckAttrs = func.node.attrs?.attributes?.elements.filter((attr) => isTypecheckArg(attr, null));
+    if (!typecheckAttrs || !typecheckAttrs.length) {
         return ret;
     }
     const callerElem = state.stack.find((elem) => elem.sn.type === "FunctionDeclaration");
@@ -2580,6 +2614,9 @@ function inlineFunction(state, func, call, context) {
     }
     const callerSn = callerElem.sn;
     const caller = callerSn.node;
+    if (caller.attrs?.attributes?.elements.find((attr) => isTypecheckArg(attr, null))) {
+        return ret;
+    }
     if (!caller.attrs) {
         caller.attrs = withLoc({
             type: "AttributeList",
@@ -2588,10 +2625,7 @@ function inlineFunction(state, func, call, context) {
     if (!caller.attrs.attributes) {
         caller.attrs.attributes = withLoc({ type: "Attributes", elements: [] }, caller.attrs, false);
     }
-    if (caller.attrs.attributes.elements.find((attr) => isTypecheckArg(attr, null))) {
-        return ret;
-    }
-    caller.attrs.attributes.elements.unshift(withLocDeep({ ...typecheckFalse }, caller.attrs, false));
+    caller.attrs.attributes.elements.unshift(...typecheckAttrs.map((typecheck) => withLocDeep({ ...typecheck }, caller.attrs, false)));
     return ret;
 }
 function applyTypeIfNeeded(node) {
@@ -3177,6 +3211,8 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
     state.localsStack = [{}];
     state.calledFunctions = {};
     state.usedByName = {};
+    const checkLookupRules = config.checkCompilerLookupRules;
+    config.checkCompilerLookupRules = "OFF";
     let again = false;
     const optimizeCallHelper = (istate, call, node) => {
         const result = optimizeCall(istate, call, node);
@@ -3749,6 +3785,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
             return ret;
         });
     });
+    config.checkCompilerLookupRules = checkLookupRules;
     reportMissingSymbols(state, config);
     if (state.inlineDiagnostics) {
         if (!state.diagnostics) {
@@ -3970,7 +4007,9 @@ function pragmaChecker(state, ast, diagnostics) {
         if (quote === '"') {
             return haystack.includes(needle);
         }
-        const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat.replace(/\W/g, "_")}(?:_\\d+)?)`));
+        const re = new RegExp(needle.replace(/@([-\d.\w]+|"[^"]*")/g, (_match, pat) => `(?:${pat}|pre_${pat
+            .replace(/^([a-zA-Z_]+\.)*/, "")
+            .replace(/\W/g, "_")}(?:_\\d+)?)`));
         return re.test(haystack);
     };
     next();
@@ -4167,7 +4206,9 @@ function sizeBasedPRE(state, func) {
         applyReplacements(func.node, nodeMap, declMap);
         func.node.body.body.unshift(variableDecl);
     }
-    minimizeLocals(state, func);
+    if (state.config?.minimizeLocals ?? true) {
+        minimizeLocals(state, func);
+    }
 }
 function buildPREGraph(state, func) {
     const result = buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
@@ -4825,18 +4866,20 @@ function applyReplacements(func, nodeMap, declMap) {
 /* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5101);
 /* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8180);
 /* harmony import */ var _function_info__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(819);
-/* harmony import */ var _optimizer_types__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(9697);
-/* harmony import */ var _type_flow_could_be__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(4055);
-/* harmony import */ var _type_flow_dead_store__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(8486);
-/* harmony import */ var _type_flow_interp__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(7161);
-/* harmony import */ var _type_flow_interp_call__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(2222);
-/* harmony import */ var _type_flow_intersection_type__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(6973);
-/* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(9234);
-/* harmony import */ var _type_flow_type_flow_util__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(1638);
-/* harmony import */ var _type_flow_types__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(7255);
-/* harmony import */ var _type_flow_union_type__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(757);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(6906);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_16__);
+/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(333);
+/* harmony import */ var _optimizer_types__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(9697);
+/* harmony import */ var _type_flow_could_be__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(4055);
+/* harmony import */ var _type_flow_dead_store__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(8486);
+/* harmony import */ var _type_flow_interp__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(7161);
+/* harmony import */ var _type_flow_interp_call__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(2222);
+/* harmony import */ var _type_flow_intersection_type__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(6973);
+/* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(9234);
+/* harmony import */ var _type_flow_type_flow_util__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(1638);
+/* harmony import */ var _type_flow_types__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(7255);
+/* harmony import */ var _type_flow_union_type__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(757);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_17___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_17__);
+
 
 
 
@@ -4875,15 +4918,24 @@ function buildTypeInfo(state, func, optimizeEquivalencies) {
     const logThisRun = logging && loggingEnabledFor("TYPEFLOW_FUNC", func);
     while (true) {
         const { graph } = buildDataFlowGraph(state, func, () => false, false, true);
-        if (optimizeEquivalencies &&
-            eliminateDeadStores(state, func, graph, logThisRun)) {
-            /*
-             * eliminateDeadStores can change the control flow graph,
-             * so we need to recompute it if it did anything.
-             */
-            continue;
+        let copyPropStores;
+        if (optimizeEquivalencies) {
+            const result = eliminateDeadStores(state, func, graph, logThisRun);
+            if (result.changes) {
+                /*
+                 * eliminateDeadStores can change the control flow graph,
+                 * so we need to recompute it if it did anything.
+                 */
+                continue;
+            }
+            if (result.copyPropStores.size) {
+                copyPropStores = result.copyPropStores;
+            }
+        }
+        const result = propagateTypes({ ...state, stack: func.stack }, func, graph, optimizeEquivalencies, copyPropStores, logThisRun);
+        if (!result.redo) {
+            return result.istate;
         }
-        return propagateTypes({ ...state, stack: func.stack }, func, graph, optimizeEquivalencies, logThisRun).istate;
     }
 }
 function buildConflictGraph(state, func) {
@@ -4891,8 +4943,8 @@ function buildConflictGraph(state, func) {
         return;
     const logThisRun = logging && loggingEnabledFor("CONFLICT_FUNC", func);
     const { graph, identifiers } = buildDataFlowGraph(state, func, () => false, false, true);
-    const { nodeEquivs } = propagateTypes({ ...state, stack: func.stack }, func, graph, false, false);
-    const { locals, localConflicts } = findDeadStores(func, graph, nodeEquivs, logThisRun);
+    const { nodeEquivs } = propagateTypes({ ...state, stack: func.stack }, func, graph, false, undefined, logThisRun);
+    const { locals, localConflicts } = findDeadStores(func, graph, nodeEquivs, false, logThisRun);
     return { graph, localConflicts, locals, identifiers, logThisRun };
 }
 function addEquiv(ts, key, equiv) {
@@ -5012,12 +5064,18 @@ function clearAssocPaths(blockState, decl, v) {
     }
 }
 function cloneTypeState(blockState) {
-    const { map, trackedMemberDecls, ...rest } = blockState;
+    const { map, trackedMemberDecls, liveCopyPropEvents, ...rest } = blockState;
     const clone = { map: new Map(map), ...rest };
     if (trackedMemberDecls) {
         clone.trackedMemberDecls = new Map();
         trackedMemberDecls.forEach((value, key) => {
-            clone.trackedMemberDecls.set(key, new Map(value));
+            clone.trackedMemberDecls.set(key, new Set(value));
+        });
+    }
+    if (liveCopyPropEvents) {
+        clone.liveCopyPropEvents = new Map();
+        liveCopyPropEvents.forEach((value, key) => {
+            clone.liveCopyPropEvents?.set(key, new Set(value));
         });
     }
     return clone;
@@ -5029,18 +5087,84 @@ function addTrackedMemberDecl(blockState, key, assocKey) {
     assocKey.split(".").forEach((pathItem) => {
         const entries = blockState.trackedMemberDecls.get(pathItem);
         if (!entries) {
-            blockState.trackedMemberDecls.set(pathItem, new Map([[key, new Set([assocKey])]]));
+            blockState.trackedMemberDecls.set(pathItem, new Set([key]));
             return;
         }
-        const entry = entries.get(key);
-        if (!entry) {
-            entries.set(key, new Set([assocKey]));
-            return;
+        entries.add(key);
+    });
+}
+function addCopyPropEvent(blockState, item) {
+    if (!blockState.liveCopyPropEvents) {
+        blockState.liveCopyPropEvents = new Map();
+    }
+    const liveCopyPropEvents = blockState.liveCopyPropEvents;
+    const decl = item.event.decl;
+    assert(declIsLocal(decl));
+    let tov = blockState.map.get(decl);
+    assert(tov);
+    if (tov.copyPropItem !== item) {
+        tov = { ...tov, copyPropItem: item };
+        blockState.map.set(decl, tov);
+    }
+    item.contained.forEach((value, key) => {
+        const decls = liveCopyPropEvents.get(key);
+        if (!decls) {
+            liveCopyPropEvents.set(key, new Set([decl]));
+        }
+        else {
+            decls.add(decl);
         }
-        entry.add(assocKey);
     });
 }
-function mergeTypeState(blockStates, index, from) {
+function clearCopyProp(blockState, item) {
+    const liveCopyPropEvents = blockState.liveCopyPropEvents;
+    assert(liveCopyPropEvents);
+    const itemDecl = item.event.decl;
+    item.contained.forEach((event, decl) => {
+        const decls = liveCopyPropEvents.get(decl);
+        assert(decls && decls.has(itemDecl));
+        decls.delete(itemDecl);
+    });
+}
+function copyPropFailed(blockState, item, nodeCopyProp) {
+    clearCopyProp(blockState, item);
+    const ref = nodeCopyProp.get(item.event.node);
+    if (ref) {
+        nodeCopyProp.delete(ref);
+    }
+    nodeCopyProp.set(item.event.node, false);
+}
+function clearRelatedCopyPropEvents(blockState, decl, nodeCopyProp) {
+    blockState.liveCopyPropEvents
+        ?.get(decl)
+        ?.forEach((cpDecl) => {
+        let value = blockState.map.get(cpDecl);
+        assert(value && value.copyPropItem);
+        assert(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) {
+    curState.liveCopyPropEvents?.forEach((decls) => decls.forEach((cpDecl) => {
+        const value = curState.map.get(cpDecl);
+        assert(value && value.copyPropItem);
+    }));
+    curState.trackedMemberDecls?.forEach((affected, key) => {
+        affected.forEach((decl) => {
+            const value = curState.map.get(decl);
+            assert(value && value.assocPaths);
+            if (!Array.from(value.assocPaths).some((path) => `.${path}.`.includes(`.${key}.`))) {
+                throw new Error("What");
+            }
+        });
+    });
+}
+function mergeTypeState(blockStates, index, from, nodeCopyProp) {
     const to = blockStates[index];
     if (!to) {
         blockStates[index] = cloneTypeState(from);
@@ -5048,9 +5172,9 @@ function mergeTypeState(blockStates, index, from) {
         return true;
     }
     const widen = ++to.visits > 10;
-    // we'll rebuild this from scratch via
-    // addTrackedMemberDecl below.
+    // we'll rebuild these from scratch
     delete to.trackedMemberDecls;
+    delete to.liveCopyPropEvents;
     let changes = false;
     to.map.forEach((tov, k) => {
         const fromv = from.map.get(k);
@@ -5069,25 +5193,57 @@ function mergeTypeState(blockStates, index, from) {
             }
         }
         if (tov.assocPaths) {
-            const assocPaths = new Set(tov.assocPaths);
             tov = { ...tov };
             if (!fromv.assocPaths) {
                 changes = true;
                 delete tov.assocPaths;
             }
             else {
+                const assocPaths = new Set(tov.assocPaths);
                 assocPaths.forEach((key) => {
                     if (!fromv.assocPaths.has(key)) {
                         assocPaths.delete(key);
+                        changes = true;
                     }
                     else {
                         addTrackedMemberDecl(to, k, key);
                     }
                 });
-                tov.assocPaths = assocPaths;
+                if (assocPaths.size) {
+                    tov.assocPaths = assocPaths;
+                }
+                else {
+                    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.
+        if (tov.copyPropItem) {
+            if (tov.copyPropItem.event !== fromv.copyPropItem?.event) {
+                const toProp = nodeCopyProp.get(tov.copyPropItem.event.node);
+                if (toProp) {
+                    nodeCopyProp.delete(toProp);
+                }
+                nodeCopyProp.set(tov.copyPropItem.event.node, false);
+                if (fromv.copyPropItem) {
+                    const fromProp = nodeCopyProp.get(fromv.copyPropItem.event.node);
+                    if (fromProp) {
+                        nodeCopyProp.delete(fromProp);
+                    }
+                    nodeCopyProp.set(fromv.copyPropItem.event.node, false);
+                }
+                tov = { ...tov };
+                delete tov.copyPropItem;
+                changes = true;
+                to.map.set(k, tov);
+            }
+            else {
+                assert(k === tov.copyPropItem.event.decl);
+                addCopyPropEvent(to, tov.copyPropItem);
+            }
+        }
         if (widen) {
             if (subtypeOf(fromv.curType, tov.curType))
                 return;
@@ -5116,9 +5272,7 @@ function tsEquivs(state, key) {
     do {
         result.push(tsKey(s));
         const next = state.get(s);
-        if (!next || !next.equivSet) {
-            throw new Error(`Inconsistent equivSet for ${tsKey(key)}: missing value for ${tsKey(s)}`);
-        }
+        assert(next && next.equivSet);
         s = next.equivSet.next;
     } while (s !== key);
     return `[(${result.join(", ")})]`;
@@ -5137,17 +5291,20 @@ function printBlockState(block, state, indent = "") {
     });
 }
 function updateAffected(blockState, objectType, baseDecl, assignedPath, affectedName, affected, assignedType) {
-    affected.forEach((paths, key) => {
+    affected.forEach((key) => {
+        let droppedComponents = null;
         const entry = blockState.map.get(key);
-        assert(entry);
+        assert(entry && entry.assocPaths);
         let newEntry = entry;
-        paths.forEach((path) => {
+        entry.assocPaths.forEach((path) => {
             if (key === baseDecl && path === assignedPath) {
                 return;
             }
-            assert(entry.assocPaths?.has(path));
-            const assocPath = [];
             const pathSegments = path.split(".");
+            if (!pathSegments.includes(affectedName)) {
+                return;
+            }
+            const assocPath = [];
             let type = entry.curType;
             for (let i = 0; i < pathSegments.length; i++) {
                 const pathItem = pathSegments[i];
@@ -5157,20 +5314,25 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
                 });
                 if (pathItem === affectedName && couldBeShallow(type, objectType)) {
                     const newAssocKey = assocPath.map((av) => av.name ?? "*").join(".");
-                    const baseType = updateByAssocPath(assocPath, assignedType, true);
                     if (newEntry === entry) {
                         newEntry = { ...entry };
                     }
-                    newEntry.curType = baseType;
-                    if (path !== newAssocKey) {
-                        newEntry.assocPaths = new Set(entry.assocPaths);
+                    if (newAssocKey !== path) {
+                        newEntry.assocPaths = new Set(newEntry.assocPaths);
                         newEntry.assocPaths.delete(path);
-                        newEntry.assocPaths.add(newAssocKey);
-                        const newPaths = new Set(paths);
-                        newPaths.delete(path);
-                        newPaths.add(newAssocKey);
-                        affected.set(key, newPaths);
+                        // 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
+                        if (!droppedComponents) {
+                            droppedComponents = new Set();
+                        }
+                        while (++i < pathSegments.length) {
+                            droppedComponents.add(pathSegments[i]);
+                        }
+                        break;
                     }
+                    const baseType = updateByAssocPath(assocPath, assignedType, true);
+                    newEntry.curType = baseType;
                     break;
                 }
                 if (pathItem === "*") {
@@ -5201,11 +5363,17 @@ 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);
         }
     });
 }
-function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
+function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStores, logThisRun) {
     // We want to traverse the blocks in reverse post order, in
     // order to propagate the "availability" of the types.
     const order = getPostOrder(graph).reverse();
@@ -5227,7 +5395,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             printBlockTrailer(block);
         });
     }
-    function memberDeclInfo(blockState, decl, clearEquiv, newValue) {
+    function memberDeclInfo(blockState, decl, newValue) {
         const baseType = getStateType(blockState, decl.base);
         const typePath = [baseType];
         let next = null;
@@ -5307,13 +5475,11 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
         }));
         const assocKey = assocValue.map((av) => av.name ?? "*").join(".");
         const newType = updateByAssocPath(assocValue, next, false);
-        setStateEvent(blockState, decl.base, newType, false);
-        // setStateEvent guarantees that tsv is "unshared" at this
-        // point. So we can munge it directly.
-        const tsv = blockState.map.get(decl.base);
-        if (!tsv.assocPaths)
-            tsv.assocPaths = new Set();
+        setStateEvent(blockState, decl.base, newType, newValue ? 1 /* UpdateKind.Inner */ : 0 /* UpdateKind.None */);
+        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];
@@ -5341,7 +5507,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                             const doUpdate = (key, cur) => {
                                 const update = cloneType(cur.curType);
                                 unionInto(update, next);
-                                setStateEvent(blockState, key, update, false);
+                                setStateEvent(blockState, key, update, 0 /* UpdateKind.None */);
                             };
                             if (decls.length === 1) {
                                 const cur = blockState.map.get(decls[0]);
@@ -5375,16 +5541,30 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             return cur;
         }, { type: 0 /* TypeTag.Never */ });
     }
-    function setStateEvent(blockState, decl, value, clearEquiv) {
+    function setStateEvent(blockState, decl, value, updateKind) {
         if (Array.isArray(decl) ||
             (decl.type !== "MemberDecl" && decl.type !== "Unknown")) {
-            const v = { ...blockState.map.get(decl) };
-            if (!clearEquiv) {
+            if (updateKind !== 0 /* UpdateKind.None */) {
+                // even if we're only modifying an Object, rather
+                // than reassigning it, we need to clear the
+                // related copy prop events, because although
+                // we may only see the object itself, the expression
+                // could access its fields. eg if x is the decl, then
+                //
+                //   foo(x);
+                //
+                // might change when x.a.b.c is changed, even if we know
+                // that foo is side-effect free, and accesses no globals.
+                clearRelatedCopyPropEvents(blockState, decl, nodeCopyProp);
+            }
+            if (updateKind !== 2 /* UpdateKind.Reassign */) {
                 /*
-                 * If we're not clearing the equivalencies then this update
-                 * must be applied to every element of the set
+                 * If we're not re-assigning, the equivalencies don't
+                 * change, so this update must be applied to every
+                 * element of the set
                  */
-                if (v.equivSet) {
+                const v = blockState.map.get(decl);
+                if (v?.equivSet) {
                     let s = decl;
                     do {
                         const next = blockState.map.get(s);
@@ -5394,25 +5574,28 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         blockState.map.set(s, { ...next, curType: value });
                         s = next.equivSet.next;
                     } while (s !== decl);
-                    return;
+                }
+                else {
+                    blockState.map.set(decl, { ...v, curType: value });
                 }
             }
             else {
+                const v = blockState.map.get(decl);
                 removeEquiv(blockState.map, decl);
-                delete v.equivSet;
-                if (v.assocPaths?.size) {
+                if (v?.assocPaths?.size) {
                     clearAssocPaths(blockState, decl, v);
-                    delete v.assocPaths;
                 }
+                if (v?.copyPropItem) {
+                    copyPropFailed(blockState, v.copyPropItem, nodeCopyProp);
+                }
+                blockState.map.set(decl, { curType: value });
             }
-            v.curType = value;
-            blockState.map.set(decl, v);
             return;
         }
         if (decl.type === "Unknown") {
             return;
         }
-        return memberDeclInfo(blockState, decl, clearEquiv, value)?.[1];
+        return memberDeclInfo(blockState, decl, value)?.[1];
     }
     function getStateType(blockState, decl) {
         return getStateEntry(blockState, decl).curType;
@@ -5430,7 +5613,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
         if (decl.type === "Unknown") {
             return { curType: { type: 0 /* TypeTag.Never */ } };
         }
-        const info = memberDeclInfo(blockState, decl, false);
+        const info = memberDeclInfo(blockState, decl);
         return { curType: info ? info[0] : { type: 524287 /* TypeTag.Any */ } };
     }
     const blockStates = [];
@@ -5451,23 +5634,58 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             if (succ.order == null) {
                 throw new Error("Unreachable block was visited");
             }
-            if (mergeTypeState(blockStates, succ.order, curState)) {
+            if (mergeTypeState(blockStates, succ.order, curState, nodeCopyProp)) {
+                if (logThisRun) {
+                    console.log(`re-merge: ${top.order} -> ${succ.order}`);
+                }
                 queue.enqueue(succ);
             }
         });
     };
-    function handleMod(curState, calleeObjDecl, callees, node) {
+    function checkModResults(curState, calleeObjDecl, callees, node) {
         const calleeObj = getStateType(curState, calleeObjDecl);
-        return every(callees, (callee) => {
-            const info = sysCallInfo(callee);
+        const calleeResult = { type: 0 /* TypeTag.Never */ };
+        const result = every(callees, (callee) => {
+            const info = sysCallInfo(istate.state, callee);
             if (!info)
                 return false;
             const result = info(istate.state, callee, calleeObj, () => node.arguments.map((arg) => evaluateExpr(state, arg, typeMap).value));
+            if (!result.effectFree) {
+                return false;
+            }
             if (result.calleeObj) {
-                setStateEvent(curState, calleeObjDecl, result.calleeObj, false);
+                unionInto(calleeResult, result.calleeObj);
             }
             return true;
         });
+        return result ? calleeResult : null;
+    }
+    function modInterference(blockState, event, doUpdate, callback) {
+        let callees = undefined;
+        if (event.calleeDecl) {
+            const calleeType = getStateType(blockState, event.calleeDecl);
+            if (hasValue(calleeType) && calleeType.type === 8192 /* TypeTag.Function */) {
+                callees = calleeType.value;
+            }
+            else {
+                callees = findCalleesByNode(state, event.node);
+            }
+        }
+        if (callees === undefined && event.callees !== undefined) {
+            callees = event.callees;
+        }
+        if (event.calleeObj) {
+            const calleeObjResult = checkModResults(blockState, event.calleeObj, callees, event.node);
+            if (calleeObjResult) {
+                if (calleeObjResult.type !== 0 /* TypeTag.Never */) {
+                    if (doUpdate) {
+                        setStateEvent(blockState, event.calleeObj, calleeObjResult, 0 /* UpdateKind.None */);
+                    }
+                }
+                return true;
+            }
+        }
+        return callback(callees, event.calleeObj);
     }
     function handleFlowEvent(event, top, curState) {
         const fixTypes = (equal, left, right, leftDecl, rightDecl) => {
@@ -5487,7 +5705,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                     }
                 }
                 const tmpState = cloneTypeState(curState);
-                setStateEvent(tmpState, leftDecl, leftr, false);
+                setStateEvent(tmpState, leftDecl, leftr, 0 /* UpdateKind.None */);
                 if (rightDecl) {
                     let rightr = restrictByEquality(left, right);
                     if (rightr.type === 0 /* TypeTag.Never */) {
@@ -5499,7 +5717,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                             return false;
                         }
                     }
-                    setStateEvent(tmpState, rightDecl, rightr, false);
+                    setStateEvent(tmpState, rightDecl, rightr, 0 /* UpdateKind.None */);
                 }
                 return tmpState;
             }
@@ -5513,7 +5731,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 if (singletonRemoved.type === 0 /* TypeTag.Never */)
                     return false;
                 const tmpState = cloneTypeState(curState);
-                setStateEvent(tmpState, leftDecl, singletonRemoved, false);
+                setStateEvent(tmpState, leftDecl, singletonRemoved, 0 /* UpdateKind.None */);
                 return tmpState;
             }
             return null;
@@ -5545,7 +5763,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                             if (singletonRemoved.type === 0 /* TypeTag.Never */)
                                 return false;
                             const tmpState = cloneTypeState(curState);
-                            setStateEvent(tmpState, event.left, singletonRemoved, false);
+                            setStateEvent(tmpState, event.left, singletonRemoved, 0 /* UpdateKind.None */);
                             return tmpState;
                         }
                     }
@@ -5560,7 +5778,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         if (nonNullRemoved.type === 0 /* TypeTag.Never */)
                             return false;
                         const tmpState = cloneTypeState(curState);
-                        setStateEvent(tmpState, event.left, nonNullRemoved, false);
+                        setStateEvent(tmpState, event.left, nonNullRemoved, 0 /* UpdateKind.None */);
                         return tmpState;
                     }
                     break;
@@ -5618,7 +5836,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                     }
                     if (result) {
                         const tmpState = cloneTypeState(curState);
-                        setStateEvent(tmpState, event.left, result, false);
+                        setStateEvent(tmpState, event.left, result, 0 /* UpdateKind.None */);
                         return tmpState;
                     }
                 }
@@ -5645,7 +5863,10 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 console.log(`  Flow (true): merge to ${trueSucc.order || -1}`);
                 printBlockState(top, sTrue || curState, "    >true ");
             }
-            if (mergeTypeState(blockStates, trueSucc.order, sTrue || curState)) {
+            if (mergeTypeState(blockStates, trueSucc.order, sTrue || curState, nodeCopyProp)) {
+                if (logThisRun) {
+                    console.log(`re-merge: ${top.order} -> ${trueSucc.order}`);
+                }
                 queue.enqueue(trueSucc);
             }
         }
@@ -5657,22 +5878,33 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 console.log(`  Flow (false): merge to: ${falseSucc.order || -1}`);
                 printBlockState(top, sFalse || curState, "    >false ");
             }
-            if (mergeTypeState(blockStates, falseSucc.order, sFalse || curState)) {
+            if (mergeTypeState(blockStates, falseSucc.order, sFalse || curState, nodeCopyProp)) {
+                if (logThisRun) {
+                    console.log(`re-merge: ${top.order} -> ${falseSucc.order}`);
+                }
                 queue.enqueue(falseSucc);
             }
         }
         return true;
     }
+    /*
+     * nodeCopyProp contains two related maps. It maps ref nodes
+     * to the def node that should be copy propagated. It also maps
+     * def nodes to false, to indicate a previous failure to find
+     * a copy prop candidate.
+     */
+    const nodeCopyProp = new Map();
     const nodeEquivs = new Map();
     const localDecls = new Map();
     const localConflicts = new Set();
     const selfAssignments = new Set();
     const processEvent = (top, curState, event, skipMerge) => {
         if (!skipMerge && event.mayThrow && top.exsucc) {
-            if (mergeTypeState(blockStates, top.exsucc.order, curState)) {
+            if (mergeTypeState(blockStates, top.exsucc.order, curState, nodeCopyProp)) {
                 queue.enqueue(top.exsucc);
             }
         }
+        validateTypeState(curState);
         switch (event.type) {
             case "kil": {
                 const curEntry = getStateEntry(curState, event.decl);
@@ -5682,11 +5914,15 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 if (curEntry.assocPaths) {
                     clearAssocPaths(curState, event.decl, curEntry);
                 }
+                if (curEntry.copyPropItem) {
+                    copyPropFailed(curState, curEntry.copyPropItem, nodeCopyProp);
+                }
+                clearRelatedCopyPropEvents(curState, event.decl, nodeCopyProp);
                 curState.map.delete(event.decl);
                 break;
             }
             case "ref": {
-                const curEntry = getStateEntry(curState, event.decl);
+                let curEntry = getStateEntry(curState, event.decl);
                 typeMap.set(event.node, curEntry.curType);
                 nodeEquivs.delete(event.node);
                 if (curEntry.equivSet) {
@@ -5698,6 +5934,26 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         });
                     }
                 }
+                if (copyPropStores) {
+                    nodeCopyProp.delete(event.node);
+                    if (curEntry.copyPropItem) {
+                        const copyPropInfo = copyPropStores.get(curEntry.copyPropItem.event.node);
+                        assert(copyPropInfo && copyPropInfo.ref === event.node);
+                        const defNode = nodeCopyProp.get(curEntry.copyPropItem.event.node);
+                        assert(!defNode || defNode === event.node);
+                        if (defNode !== false) {
+                            nodeCopyProp.set(event.node, curEntry.copyPropItem.event.node);
+                            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);
+                    }
+                }
                 if (logThisRun) {
                     console.log(`  ${describeEvent(event)} == ${display(curEntry.curType)}`);
                 }
@@ -5707,53 +5963,75 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 if (logThisRun) {
                     console.log(`  ${describeEvent(event)}`);
                 }
-                let callees = undefined;
-                if (event.calleeDecl) {
-                    const calleeType = getStateType(curState, event.calleeDecl);
-                    if (hasValue(calleeType) && calleeType.type === 8192 /* TypeTag.Function */) {
-                        callees = calleeType.value;
-                    }
-                    else {
-                        callees = findCalleesByNode(state, event.node);
-                    }
-                }
-                if (callees === undefined && event.callees !== undefined) {
-                    callees = event.callees;
-                }
-                if (event.calleeObj) {
-                    if (handleMod(curState, event.calleeObj, callees, event.node)) {
-                        break;
+                modInterference(curState, event, true, (callees, calleeObj) => {
+                    clearRelatedCopyPropEvents(curState, null, nodeCopyProp);
+                    if (calleeObj) {
+                        const objType = getStateType(curState, calleeObj);
+                        if (objType.type &
+                            (32768 /* TypeTag.Object */ | 512 /* TypeTag.Array */ | 1024 /* TypeTag.Dictionary */)) {
+                            setStateEvent(curState, calleeObj, objType, 1 /* UpdateKind.Inner */);
+                        }
                     }
-                }
-                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)))) {
-                        return;
+                    if (nodeCopyProp.size &&
+                        event.node.type === "CallExpression" &&
+                        some(callees, (callee) => inlineRequested(state, callee))) {
+                        // we don't want to copy-prop to the argument of
+                        // an inline function, because that could prevent
+                        // inlining.
+                        event.node.arguments.forEach((arg) => {
+                            const def = nodeCopyProp.get(arg);
+                            if (def && nodeCopyProp.get(def) !== false) {
+                                nodeCopyProp.set(def, false);
+                                nodeCopyProp.delete(arg);
+                            }
+                        });
                     }
-                    if (modifiableDecl(decl, callees)) {
-                        if (tsv.equivSet) {
-                            removeEquiv(curState.map, decl);
+                    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)))) {
+                            return;
                         }
-                        if (tsv.assocPaths) {
-                            clearAssocPaths(curState, decl, tsv);
+                        if (modifiableDecl(decl, callees)) {
+                            if (tsv.equivSet) {
+                                removeEquiv(curState.map, decl);
+                            }
+                            if (tsv.assocPaths) {
+                                clearAssocPaths(curState, decl, tsv);
+                            }
+                            // we only attach copyPropItems to locals,
+                            // which can't be modified by a call.
+                            assert(!tsv.copyPropItem);
+                            clearRelatedCopyPropEvents(curState, decl, nodeCopyProp);
+                            curState.map.set(decl, { curType: typeConstraint(decl) });
                         }
-                        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 */) {
-                            const odata = getObjectValue(tsv.curType);
-                            if (odata?.obj) {
-                                type = cloneType(type);
-                                const newData = { klass: odata.klass };
-                                setUnionComponent(type, 32768 /* TypeTag.Object */, newData);
-                                curState.map.set(decl, { ...tsv, curType: type });
+                        else if (type.value != null &&
+                            (!callees || !every(callees, (callee) => callee.info === false))) {
+                            if (type.type & 32768 /* TypeTag.Object */) {
+                                const odata = getObjectValue(tsv.curType);
+                                if (odata?.obj) {
+                                    type = cloneType(type);
+                                    const newData = { klass: odata.klass };
+                                    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 });
+                                }
                             }
                         }
-                    }
+                    });
+                    return true;
                 });
                 break;
             }
@@ -5764,9 +6042,18 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         ? event.node.left
                         : null;
                 if (lval) {
-                    const beforeType = getStateType(curState, event.decl);
-                    if (beforeType) {
-                        typeMap.set(lval, beforeType);
+                    const before = getStateEntry(curState, event.decl);
+                    if (before.curType) {
+                        typeMap.set(lval, before.curType);
+                    }
+                    if (before.copyPropItem &&
+                        (event.node.type !== "AssignmentExpression" ||
+                            event.node.operator !== "=")) {
+                        copyPropFailed(curState, before.copyPropItem, nodeCopyProp);
+                        const v = { ...before };
+                        delete v.copyPropItem;
+                        assert(isTypeStateKey(event.decl));
+                        curState.map.set(event.decl, v);
                     }
                 }
                 const expr = event.node.type === "VariableDeclarator"
@@ -5775,7 +6062,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 const type = expr
                     ? evaluate(istate, expr).value
                     : { type: 524287 /* TypeTag.Any */ };
-                const wasComputedDecl = setStateEvent(curState, event.decl, type, true);
+                const wasComputedDecl = setStateEvent(curState, event.decl, type, 2 /* UpdateKind.Reassign */);
                 some(event.decl, (decl) => {
                     if (decl.type !== "VariableDeclarator" ||
                         decl.node.kind !== "var" ||
@@ -5806,13 +6093,16 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                             if (value.assocPaths) {
                                 clearAssocPaths(curState, decls, value);
                             }
+                            assert(!value.copyPropItem);
                             curState.map.set(decls, { curType: typeConstraint(decls) });
+                            clearRelatedCopyPropEvents(curState, decls, nodeCopyProp);
                         }
                     });
                 }
                 if (event.rhs) {
                     const selfAssign = addEquiv(curState.map, event.rhs, event.decl);
-                    if (event.node.type === "AssignmentExpression") {
+                    if (event.node.type === "AssignmentExpression" &&
+                        event.node.operator === "=") {
                         if (selfAssign) {
                             // rhs and lhs are identical
                             selfAssignments.add(event.node);
@@ -5822,7 +6112,72 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         }
                     }
                 }
-                if (declIsLocal(event.decl)) {
+                if (!declIsLocal(event.decl)) {
+                    clearRelatedCopyPropEvents(curState, null, nodeCopyProp);
+                }
+                else {
+                    if (event.containedEvents &&
+                        copyPropStores &&
+                        nodeCopyProp.get(event.node) !== false &&
+                        (!event.rhs || !declIsLocal(event.rhs))) {
+                        const copyPropCandidate = copyPropStores.get(event.node);
+                        if (copyPropCandidate) {
+                            const contained = new Map();
+                            if (event.containedEvents.every((event) => {
+                                if (event.type === "mod") {
+                                    if (modInterference(curState, event, false, () => false)) {
+                                        return true;
+                                    }
+                                    if (!copyPropCandidate.ant ||
+                                        // If the ref isn't anticipated, we can't propagate it
+                                        // in case it has side effects.
+                                        some(event.calleeDecl, (callee) => callee.type === "FunctionDeclaration" &&
+                                            inlineRequested(state, callee))) {
+                                        // Don't copy prop if the rhs is marked for
+                                        // inline, because we might move it out of
+                                        // assignment context, to somewhere it can't be
+                                        // inlined.
+                                        return false;
+                                    }
+                                }
+                                if (!event.decl ||
+                                    (isTypeStateKey(event.decl) &&
+                                        some(event.decl, (decl) => (decl.type === "VariableDeclarator" &&
+                                            decl.node.kind === "var") ||
+                                            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;
+                                    }
+                                    const item = contained.get(key);
+                                    if (!item) {
+                                        contained.set(key, [event]);
+                                    }
+                                    else {
+                                        item.push(event);
+                                    }
+                                }
+                                return true;
+                            })) {
+                                addCopyPropEvent(curState, { event, contained });
+                            }
+                        }
+                    }
                     const name = localDeclName(event.decl);
                     const locals = localDecls.get(name);
                     if (!locals) {
@@ -5870,7 +6225,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
     func.node.params.forEach((param) => {
         setStateEvent(head, param, param.type === "BinaryExpression"
             ? typeFromTypespec(state, param.right)
-            : { type: 524287 /* TypeTag.Any */ }, false);
+            : { type: 524287 /* TypeTag.Any */ }, 0 /* UpdateKind.None */);
     });
     queue.enqueue(order[0]);
     while (!queue.empty()) {
@@ -5904,6 +6259,16 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             printBlockTrailer(top);
         }
     }
+    nodeCopyProp.forEach((value, key) => {
+        if (key.type === "VariableDeclarator" ||
+            key.type === "AssignmentExpression") {
+            if (value === false) {
+                nodeCopyProp.delete(key);
+                return;
+            }
+            assert(nodeCopyProp.get(value) === key);
+        }
+    });
     if (logThisRun) {
         order.forEach((block) => {
             printBlockHeader(block);
@@ -5921,9 +6286,29 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
         nodeEquivs.forEach((value, key) => {
             console.log(`${formatAst(key)} = [${value.equiv.map((equiv) => tsKey(equiv))}] ${key.loc && key.loc.source ? ` (${sourceLocation(key.loc)})` : ""}`);
         });
+        console.log("====== Copy Prop =====");
+        nodeCopyProp.forEach((value, key) => {
+            assert(value !== false);
+            if (key.type === "VariableDeclarator" ||
+                key.type === "AssignmentExpression") {
+                return;
+            }
+            assert((value.type === "VariableDeclarator" && value.init) ||
+                value.type === "AssignmentExpression");
+            const node = value.type === "VariableDeclarator" ? value.init : value.right;
+            console.log(`${formatAst(key)} = [${formatAstLongLines(node)}] ${key.loc && key.loc.source ? ` (${sourceLocation(key.loc)})` : ""}`);
+        });
+    }
+    if (logThisRun) {
+        console.log(formatAstLongLines(func.node));
+        if (copyPropStores) {
+            copyPropStores.forEach(({ ref, ant }, node) => {
+                console.log(`copy-prop-store: ${formatAstLongLines(node)}${ant ? "!" : ""} => ${nodeCopyProp.get(node) !== ref ? "Failed" : "Success"}`);
+            });
+        }
     }
     if (optimizeEquivalencies) {
-        if (!nodeEquivs.size && !selfAssignments.size) {
+        if (!nodeEquivs.size && !selfAssignments.size && !nodeCopyProp.size) {
             return { istate, nodeEquivs };
         }
         if (logThisRun) {
@@ -5967,12 +6352,60 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 }
             }));
         traverseAst(func.node.body, null, (node) => {
+            const copyNode = nodeCopyProp.get(node);
+            if (copyNode) {
+                if (node.type === "AssignmentExpression") {
+                    if (logThisRun) {
+                        console.log(`Killing copy-prop assignment ${formatAstLongLines(node)}`);
+                    }
+                    return withLoc({ type: "Literal", value: null, raw: "null" }, node, node);
+                }
+                if (node.type === "VariableDeclarator") {
+                    assert(node.init);
+                    if (logThisRun) {
+                        console.log(`Killing copy-prop variable initialization ${formatAstLongLines(node)}`);
+                    }
+                    const dup = { ...node };
+                    delete dup.init;
+                    return dup;
+                }
+                if (copyNode.type === "AssignmentExpression") {
+                    if (logThisRun) {
+                        console.log(`copy-prop ${formatAstLongLines(node)} => ${formatAstLongLines(copyNode.right)}`);
+                    }
+                    return withLocDeep(copyNode.right, node, node, false);
+                }
+                else if (copyNode.type === "VariableDeclarator") {
+                    assert(copyNode.init);
+                    if (logThisRun) {
+                        console.log(`copy-prop ${formatAstLongLines(node)} => ${formatAstLongLines(copyNode.init)}`);
+                    }
+                    return withLocDeep(copyNode.init, node, node, false);
+                }
+                assert(false);
+            }
             if (selfAssignments.has(node)) {
                 if (logThisRun) {
                     console.log(`Deleting self assignment: ${formatAst(node)} (${sourceLocation(node.loc)})`);
                 }
                 return withLoc({ type: "Literal", value: null, raw: "null" }, node, node);
             }
+            if (nodeCopyProp.size) {
+                /*
+                 * Copy prop and equiv can interfere with each other:
+                 *
+                 *   var c = g; // copy prop kills this
+                 *   ...
+                 *   var x = g + 2; // node equiv replaces g with c
+                 *   ...
+                 *   return c; // copy prop changes this to g
+                 *
+                 * So ignore equivalencies if copy prop is active.
+                 * Note that we have to re-run propagation anyway
+                 * if copy prop did anything.
+                 */
+                return null;
+            }
             const equiv = nodeEquivs.get(node);
             if (!equiv || localConflicts.has(equiv.decl))
                 return null;
@@ -6024,7 +6457,11 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             return replacement;
         });
     }
-    return { istate, nodeEquivs };
+    return {
+        istate,
+        nodeEquivs,
+        redo: optimizeEquivalencies && nodeCopyProp.size,
+    };
 }
 function updateByAssocPath(path, property, union) {
     const valueToStore = (base) => {
@@ -6261,20 +6698,48 @@ function couldBeObj(a, b) {
 
 "use strict";
 /* unused harmony exports findDeadStores, eliminateDeadStores */
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
-/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5101);
-/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8180);
-/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(333);
-/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(1638);
+/* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4143);
+/* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(node_assert__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6652);
+/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5101);
+/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8180);
+/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(333);
+/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1638);
+
 
 
 
 
 
 
-function findDeadStores(func, graph, nodeEquivs, logThisRun) {
+function cloneAnt(antMap) {
+    const ant = new Map();
+    antMap.forEach((s, k) => ant.set(k, new Set(s)));
+    return ant;
+}
+function addAnt(antMap, decl, node) {
+    assert(node.type === "Identifier");
+    const ant = antMap.get(decl);
+    if (!ant) {
+        antMap.set(decl, new Set([node]));
+    }
+    else {
+        ant.add(node);
+    }
+}
+function cloneState(blockState) {
+    const clone = { dead: new Set(blockState.dead) };
+    if (blockState.anticipated) {
+        clone.anticipated = cloneAnt(blockState.anticipated);
+    }
+    if (blockState.partiallyAnticipated) {
+        clone.partiallyAnticipated = cloneAnt(blockState.partiallyAnticipated);
+    }
+    return clone;
+}
+function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThisRun) {
     const order = getPostOrder(graph);
     order.forEach((block, i) => {
         block.order = i;
@@ -6282,13 +6747,62 @@ function findDeadStores(func, graph, nodeEquivs, logThisRun) {
     const blockStates = [];
     const nodeConflicts = nodeEquivs && new Map();
     const mergeStates = (to, from) => {
-        return Array.from(to).reduce((changed, decl) => {
-            if (!from.has(decl)) {
-                to.delete(decl);
+        let changed = Array.from(to.dead).reduce((changed, decl) => {
+            if (!from.dead.has(decl)) {
+                to.dead.delete(decl);
                 changed = true;
             }
             return changed;
         }, false);
+        if (to.anticipated) {
+            if (!from.anticipated) {
+                delete to.anticipated;
+                changed = true;
+            }
+            else {
+                changed = Array.from(to.anticipated).reduce((changed, [decl, toant]) => {
+                    const fromant = from.anticipated.get(decl);
+                    if (!fromant) {
+                        to.anticipated.delete(decl);
+                        changed = true;
+                    }
+                    else {
+                        toant.forEach((node) => {
+                            if (!fromant.has(node)) {
+                                toant.delete(node);
+                                changed = true;
+                            }
+                        });
+                    }
+                    return changed;
+                }, changed);
+            }
+        }
+        if (from.partiallyAnticipated) {
+            if (!to.partiallyAnticipated) {
+                to.partiallyAnticipated = cloneAnt(from.partiallyAnticipated);
+                changed = true;
+            }
+            else {
+                changed = Array.from(from.partiallyAnticipated).reduce((changed, [decl, fromant]) => {
+                    const toant = to.partiallyAnticipated.get(decl);
+                    if (!toant) {
+                        to.partiallyAnticipated.set(decl, fromant);
+                        changed = true;
+                    }
+                    else {
+                        fromant.forEach((node) => {
+                            if (!toant.has(node)) {
+                                changed = true;
+                                toant.add(node);
+                            }
+                        });
+                    }
+                    return changed;
+                }, changed);
+            }
+        }
+        return changed;
     };
     const queue = new DataflowQueue();
     const locals = new Set(order
@@ -6299,10 +6813,11 @@ function findDeadStores(func, graph, nodeEquivs, logThisRun) {
         : [])
         .concat(func.node.params));
     const deadStores = new Set();
+    const copyPropStores = new Map();
     order.forEach((block) => {
         if (!block.succs) {
             queue.enqueue(block);
-            blockStates[block.order] = new Set(locals);
+            blockStates[block.order] = { dead: new Set(locals) };
         }
     });
     while (!queue.empty()) {
@@ -6313,10 +6828,10 @@ function findDeadStores(func, graph, nodeEquivs, logThisRun) {
         if (!blockStates[top.order]) {
             throw new Error(`Block ${top.order || 0} had no state!`);
         }
-        const curState = new Set(blockStates[top.order]);
+        const curState = cloneState(blockStates[top.order]);
         if (logThisRun) {
             printBlockHeader(top);
-            curState.forEach((decl) => console.log(` - anticipated: ${tsKey(decl)}`));
+            curState.dead.forEach((decl) => console.log(` - anticipated: ${tsKey(decl)}`));
         }
         if (top.events) {
             for (let i = top.events.length; i--;) {
@@ -6331,33 +6846,67 @@ function findDeadStores(func, graph, nodeEquivs, logThisRun) {
                 switch (event.type) {
                     case "ref":
                         if (isTypeStateKey(event.decl)) {
-                            curState.delete(event.decl);
                             if (logThisRun) {
+                                console.log(describeEvent(event));
                                 console.log(`  kill => ${tsKey(event.decl)}`);
                             }
+                            if (findCopyPropCandidates && declIsLocal(event.decl)) {
+                                if (!curState.anticipated) {
+                                    curState.anticipated = new Map();
+                                }
+                                addAnt(curState.anticipated, event.decl, event.node);
+                                if (!curState.partiallyAnticipated) {
+                                    curState.partiallyAnticipated = new Map();
+                                }
+                                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}`);
+                                }
+                            }
+                            curState.dead.delete(event.decl);
                         }
                         break;
                     case "def":
                         if (isTypeStateKey(event.decl) &&
                             (event.node.type !== "VariableDeclarator" || event.node.init)) {
-                            if (curState.has(event.decl)) {
+                            if (logThisRun) {
+                                console.log(describeEvent(event));
+                            }
+                            const assignNode = (event.node.type === "AssignmentExpression" &&
+                                event.node.operator === "=" &&
+                                event.node.right) ||
+                                (event.node.type === "VariableDeclarator" && event.node.init);
+                            if (curState.dead.has(event.decl)) {
                                 deadStores.add(event.node);
                             }
                             else {
                                 deadStores.delete(event.node);
+                                if (assignNode &&
+                                    declIsLocal(event.decl) &&
+                                    curState.partiallyAnticipated) {
+                                    const pant = curState.partiallyAnticipated.get(event.decl);
+                                    if (pant && pant.size === 1) {
+                                        if (logThisRun) {
+                                            console.log(`  is copy-prop-candidate ${curState.anticipated?.get(event.decl)?.size ?? 0}`);
+                                        }
+                                        copyPropStores.set(event.node, {
+                                            ref: Array.from(pant)[0],
+                                            ant: curState.anticipated?.get(event.decl)?.size === 1,
+                                        });
+                                    }
+                                    curState.partiallyAnticipated.delete(event.decl);
+                                    curState.anticipated?.delete(event.decl);
+                                }
+                                else {
+                                    copyPropStores.delete(event.node);
+                                }
                             }
                             if (nodeConflicts) {
                                 const conflicts = new Set(locals);
-                                curState.forEach((dead) => conflicts.delete(dead));
+                                curState.dead.forEach((dead) => conflicts.delete(dead));
                                 if (event.rhs) {
                                     conflicts.delete(event.rhs);
-                                    const equiv = event.node.type === "AssignmentExpression" &&
-                                        event.node.operator === "="
-                                        ? nodeEquivs.get(event.node.right)
-                                        : event.node.type === "VariableDeclarator" &&
-                                            event.node.init
-                                            ? nodeEquivs.get(event.node.init)
-                                            : null;
+                                    const equiv = assignNode && nodeEquivs.get(assignNode);
                                     if (equiv) {
                                         equiv.equiv.forEach((e) => isTypeStateKey(e) && conflicts.delete(e));
                                         isTypeStateKey(equiv.decl) && conflicts.delete(equiv.decl);
@@ -6366,10 +6915,8 @@ function findDeadStores(func, graph, nodeEquivs, logThisRun) {
                                 conflicts.add(event.decl);
                                 nodeConflicts.set(event.node, conflicts);
                             }
-                            if ((event.node.type === "AssignmentExpression" &&
-                                event.node.operator === "=") ||
-                                (event.node.type === "VariableDeclarator" && event.node.init)) {
-                                curState.add(event.decl);
+                            if (assignNode) {
+                                curState.dead.add(event.decl);
                                 if (logThisRun) {
                                     console.log(`  anticipated => ${tsKey(event.decl)}`);
                                 }
@@ -6378,14 +6925,14 @@ function findDeadStores(func, graph, nodeEquivs, logThisRun) {
                         break;
                     case "kil":
                         if (isTypeStateKey(event.decl)) {
-                            curState.add(event.decl);
+                            curState.dead.add(event.decl);
                             if (logThisRun) {
                                 console.log(`  anticipated => ${tsKey(event.decl)}`);
                             }
                         }
                         break;
                     case "mod":
-                        curState.forEach((decl) => declIsLocal(decl) || curState.delete(decl));
+                        curState.dead.forEach((decl) => declIsLocal(decl) || curState.dead.delete(decl));
                         break;
                     case "flw":
                         break;
@@ -6395,7 +6942,7 @@ function findDeadStores(func, graph, nodeEquivs, logThisRun) {
         const doMerge = (pred) => {
             const pi = pred.order || 0;
             if (!blockStates[pi]) {
-                blockStates[pi] = new Set(curState);
+                blockStates[pi] = cloneState(curState);
                 queue.enqueue(pred);
             }
             else if (mergeStates(blockStates[pi], curState)) {
@@ -6427,15 +6974,18 @@ function findDeadStores(func, graph, nodeEquivs, logThisRun) {
         nodeConflicts.forEach((conflicts) => conflicts.forEach((conflict) => addConflicts(conflict, conflicts)));
         func.node.params.forEach((param, index, arr) => addConflicts(param, arr));
     }
-    return { deadStores, locals, localConflicts };
+    return { deadStores, locals, localConflicts, copyPropStores };
 }
 function eliminateDeadStores(state, func, graph, logThisRun) {
-    const { deadStores } = findDeadStores(func, graph, null, logThisRun);
+    const { deadStores, copyPropStores } = findDeadStores(func, graph, null, state.config?.singleUseCopyProp ?? true, logThisRun);
     if (!deadStores.size)
-        return false;
+        return { changes: false, copyPropStores };
     if (logThisRun) {
         console.log("====== Dead Stores =====");
-        deadStores.forEach((dead) => console.log(`${formatAst(dead)} (${sourceLocation(dead.loc)})`));
+        deadStores.forEach((dead) => (dead.type === "AssignmentExpression" ||
+            dead.type === "UpdateExpression" ||
+            dead.type === "VariableDeclarator") &&
+            console.log(`${formatAst(dead)} (${sourceLocation(dead.loc)})`));
     }
     let changes = false;
     traverseAst(func.node.body, null, (node, parent) => {
@@ -6498,7 +7048,7 @@ function eliminateDeadStores(state, func, graph, logThisRun) {
         }
         return null;
     });
-    return changes;
+    return { copyPropStores, changes };
 }
 
 
@@ -6509,9 +7059,13 @@ function eliminateDeadStores(state, func, graph, logThisRun) {
 
 "use strict";
 /* unused harmony exports evaluateBinaryTypes, evaluateLogicalTypes */
-/* harmony import */ var _interp__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7161);
-/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7255);
-/* harmony import */ var _union_type__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(757);
+/* harmony import */ var _could_be__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4055);
+/* harmony import */ var _interp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7161);
+/* harmony import */ var _sub_type__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9234);
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7255);
+/* harmony import */ var _union_type__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(757);
+
+
 
 
 
@@ -6842,14 +7396,6 @@ function evaluateBinaryTypes(op, left, right) {
                         : 2 /* TypeTag.False */,
                 }),
             },
-            instanceof: {
-                allowed: 524287 /* TypeTag.Any */,
-                typeFn: () => ({
-                    tag: 6 /* TypeTag.Boolean */,
-                    castArgs: false,
-                }),
-                valueFn: (_left, _right) => undefined,
-            },
             has: {
                 allowed: 524287 /* TypeTag.Any */,
                 typeFn: () => ({
@@ -6860,6 +7406,21 @@ function evaluateBinaryTypes(op, left, right) {
             },
         };
     }
+    if (op === "instanceof") {
+        if (right.type & 16384 /* TypeTag.Class */) {
+            if (!isExact(right)) {
+                return { type: 6 /* TypeTag.Boolean */ };
+            }
+            right = { type: 32768 /* TypeTag.Object */, value: { klass: right } };
+        }
+        return {
+            type: subtypeOf(left, right)
+                ? 4 /* TypeTag.True */
+                : !couldBeWeak(left, right)
+                    ? 2 /* TypeTag.False */
+                    : 6 /* TypeTag.Boolean */,
+        };
+    }
     const info = operators[op];
     if (!info)
         return { type: 524287 /* TypeTag.Any */ };
@@ -6982,7 +7543,7 @@ function checkCallArgs(istate, node, callees, args) {
         let argEffects = true;
         const object = calleeObjectType(istate, node.callee);
         if (object) {
-            const info = sysCallInfo(cur);
+            const info = sysCallInfo(istate.state, cur);
             if (info) {
                 const result = info(istate.state, cur, object, () => args);
                 if (result.argTypes)
@@ -7113,16 +7674,18 @@ function isOverride(cur, funcs) {
     return false;
 }
 let systemCallInfo = null;
-function sysCallInfo(func) {
-    const info = getSystemCallTable();
+let systemCallVersion;
+function sysCallInfo(state, func) {
+    const info = getSystemCallTable(state);
     if (hasProperty(info, func.fullName)) {
         return info[func.fullName];
     }
     return null;
 }
-function getSystemCallTable() {
-    if (systemCallInfo)
+function getSystemCallTable(state) {
+    if (systemCallInfo && systemCallVersion === state.sdk) {
         return systemCallInfo;
+    }
     const arrayAdd = (state, callee, calleeObj, getArgs) => {
         const ret = {};
         if (calleeObj.type & 512 /* TypeTag.Array */) {
@@ -7342,7 +7905,8 @@ function getSystemCallTable() {
         }
         return results;
     };
-    return (systemCallInfo = {
+    systemCallVersion = state.sdk;
+    return (systemCallInfo = expandKeys(state, {
         "$.Toybox.Lang.Array.add": arrayAdd,
         "$.Toybox.Lang.Array.addAll": arrayAdd,
         "$.Toybox.Lang.Array.remove": mod,
@@ -7385,7 +7949,47 @@ function getSystemCallTable() {
         "$.Toybox.Math.variance": nop,
         "$.Toybox.Math.srand": mod,
         "$.Toybox.Math.rand": mod,
+        "$.Toybox.Lang.*.(to*|equals|abs)": nop,
+        "$.Toybox.Time.Gregorian.(duration|info|localMoment|moment|utcInfo)": nop,
+        "$.Toybox.Time.(Duration|LocalMoment|Moment).(?!initialize)*": nop,
+        "$.Toybox.Graphics.Dc.get*": nop,
+    }));
+}
+function expandKeys(state, table) {
+    const result = {};
+    const pattern = /[*()|]/;
+    Object.entries(table).forEach(([key, value]) => {
+        if (!pattern.test(key)) {
+            result[key] = value;
+            return;
+        }
+        if (state.stack) {
+            const decls = key
+                .split(".")
+                .slice(1)
+                .reduce((decls, decl) => {
+                if (pattern.test(decl)) {
+                    const re = new RegExp(`^${decl.replace(/\*/g, ".*")}$`);
+                    return decls.flatMap((sn) => isStateNode(sn) && sn.decls
+                        ? Object.keys(sn.decls)
+                            .filter((m) => re.test(m))
+                            .flatMap((m) => sn.decls[m])
+                        : []);
+                }
+                else {
+                    return decls.flatMap((sn) => (isStateNode(sn) && sn.decls?.[decl]) || []);
+                }
+            }, [state.stack[0].sn]);
+            decls.forEach((decl) => {
+                if (decl.type === "FunctionDeclaration") {
+                    if (!hasProperty(result, decl.fullName)) {
+                        result[decl.fullName] = value;
+                    }
+                }
+            });
+        }
     });
+    return result;
 }
 
 
@@ -9064,6 +9668,24 @@ function optimizeFunction(state, func) {
 }
 function beforeEvaluate(istate, node) {
     switch (node.type) {
+        case "ExpressionStatement": {
+            if (node.expression.type !== "Literal") {
+                const expression = popIstate(istate, node.expression);
+                if (expression.embeddedEffects) {
+                    istate.stack.push(expression);
+                }
+                else {
+                    const rep = withLoc({ type: "Literal", value: null, raw: "null" }, node, node);
+                    istate.stack.push({
+                        value: { type: 1 /* TypeTag.Null */ },
+                        embeddedEffects: false,
+                        node: rep,
+                    });
+                    node.expression = rep;
+                }
+            }
+            break;
+        }
         case "ConditionalExpression": {
             let alternate = tryPop(istate, node.alternate);
             let consequent = tryPop(istate, node.consequent);
@@ -9812,7 +10434,7 @@ function subtypeOfObj(a, b) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "nK": () => (/* binding */ findObjectDeclsByProperty)
 /* harmony export */ });
-/* unused harmony exports isTypeStateKey, declIsLocal, localDeclName, tsKey, sourceLocation, printBlockHeader, describeEvent, printBlockEvents, printBlockTrailer, refineObjectTypeByDecls, findNextObjectType, resolveDottedMember */
+/* unused harmony exports isTypeStateKey, declIsLocal, declIsNonLocal, localDeclName, tsKey, sourceLocation, printBlockHeader, describeEvent, printBlockEvents, printBlockTrailer, refineObjectTypeByDecls, findNextObjectType, resolveDottedMember */
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8180);
@@ -9838,6 +10460,9 @@ function declIsLocal(decl) {
         d.type === "Identifier" ||
         (d.type === "VariableDeclarator" && isLocal(d)));
 }
+function declIsNonLocal(decl) {
+    return some(decl, (d) => d.type === "VariableDeclarator" && !isLocal(d));
+}
 function localDeclName(decl) {
     if (Array.isArray(decl))
         decl = decl[0];
@@ -11300,6 +11925,23 @@ function cleanupUnusedVars(state, node) {
         return false;
     const varDeclarations = new Map();
     const stack = [];
+    /*
+     * Every local mentioned in toRemove can be removed, but
+     * occurances of the identifier prior to its declaration
+     * must be non-local. So reconstruct the toRemove record
+     * as we go. This is to prevent issues with something like
+     *
+     * var g = 0;
+     * function foo(var h) {
+     *   // if we just consult toRemove, we'll remove this assignment
+     *   g = h * 2;
+     *   var x = g;
+     *   ...
+     *   // *This* g is unused, and "g" gets added to activeRemove here.
+     *   var g = 42;
+     * }
+     */
+    const activeRemove = {};
     let changes = false;
     traverseAst(node, (node) => {
         switch (node.type) {
@@ -11320,6 +11962,7 @@ function cleanupUnusedVars(state, node) {
                 node.declarations.forEach((decl, i) => {
                     const name = variableDeclarationName(decl.id);
                     if (hasProperty(toRemove, name)) {
+                        activeRemove[name] = toRemove[name];
                         const info = varDeclarations.get(node);
                         if (info) {
                             info.indices.push(i);
@@ -11337,14 +11980,14 @@ function cleanupUnusedVars(state, node) {
             case "ExpressionStatement":
                 if (node.expression.type === "AssignmentExpression") {
                     if (node.expression.left.type === "Identifier" &&
-                        hasProperty(toRemove, node.expression.left.name)) {
+                        hasProperty(activeRemove, node.expression.left.name)) {
                         changes = true;
                         return unused(state, node.expression.right);
                     }
                 }
                 else if (node.expression.type === "UpdateExpression" &&
                     node.expression.argument.type === "Identifier" &&
-                    hasProperty(toRemove, node.expression.argument.name)) {
+                    hasProperty(activeRemove, node.expression.argument.name)) {
                     return false;
                 }
                 break;
@@ -11353,7 +11996,7 @@ function cleanupUnusedVars(state, node) {
                     const expr = node.expressions[i];
                     if (expr.type === "AssignmentExpression") {
                         if (expr.left.type === "Identifier" &&
-                            hasProperty(toRemove, expr.left.name)) {
+                            hasProperty(activeRemove, expr.left.name)) {
                             const rep = unused(state, expr.right);
                             if (!rep.length) {
                                 changes = true;
@@ -11362,14 +12005,14 @@ function cleanupUnusedVars(state, node) {
                             else {
                                 // Sequence expressions can only be assignments
                                 // or update expressions. Even calls aren't allowed
-                                toRemove[expr.left.name] = null;
+                                activeRemove[expr.left.name] = null;
                                 expr.operator = "=";
                             }
                         }
                     }
                     else if (expr.type === "UpdateExpression" &&
                         expr.argument.type === "Identifier" &&
-                        hasProperty(toRemove, expr.argument.name)) {
+                        hasProperty(activeRemove, expr.argument.name)) {
                         changes = true;
                         node.expressions.splice(i, 1);
                     }
@@ -11385,7 +12028,7 @@ function cleanupUnusedVars(state, node) {
             const i = info.indices[ii];
             const vdecl = decl.declarations[i];
             const name = variableDeclarationName(vdecl.id);
-            if (hasProperty(toRemove, name)) {
+            if (hasProperty(activeRemove, name)) {
                 const rep = vdecl.init ? unused(state, vdecl.init) : [];
                 if (rep.length) {
                     if ((state.sdkVersion || 0) < 4001007 &&
@@ -11430,7 +12073,7 @@ function cleanupUnusedVars(state, node) {
                     j = i;
                     continue;
                 }
-                if (toRemove[name]) {
+                if (activeRemove[name]) {
                     changes = true;
                     j--;
                     decl.declarations.splice(i, 1);
@@ -13392,13 +14035,14 @@ async function createDocumentationMap(functionDocumentation) {
         state.allFunctions[info.name]?.forEach((decl) => decl.node?.loc?.source === "api.mir" &&
             decl.fullName.endsWith(`.${info.parent}.${info.name}`) &&
             docMap.set(decl.fullName, info.doc
+                .replace(/@example\s*(.*?)<br\/>(.*?)(@|$)/g, (match, title, m1, m2) => `\n#### Example: ${title}\n\`\`\`${m1.replace(/<br\/>/g, "\n")}\`\`\`${m2}`)
                 .replace(/(\*.*?)\s*<br\/>\s*(?!\s*\*)/g, "$1\n\n")
-                .replace(/@example(.*?)(@|$)/g, (match, m1, m2) => `\n#### Example\n\`\`\`${m1.replace(/<br\/>/g, "\n")}\`\`\`${m2}`)
                 .replace(/@note/g, "\n#### Note\n")
                 .replace(/@see/, "\n#### See Also:\n$&")
                 .replace(/@see\s+(.*?)(?=<br\/>)/g, "\n  * {$1}")
                 .replace(/@throws/, "\n#### Throws:\n$&")
                 .replace(/@throws\s+(.*?)(?=<br\/>)/g, "\n  * $1")
+                .replace(/@option\s+\w+\s+(.*?)(?=<br\/>)/g, "\n  - $1")
                 .replace(/@since\s+(.*?)(?=<br\/>)/, "\n#### Since:\nAPI Level $1\n")
                 .replace(/<div class="description">/, "### Description\n")
                 .replace(/<div class="param">/, "\n#### Parameters\n$&")