@markw65/monkeyc-optimizer 1.1.9 → 1.1.11

package/build/api.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {checkCompilerVersion,collectNamespaces,createDocumentationMap,diagnostic,diagnosticHelper,findNamesInScope,findUsingForNode,formatAst,formatAstLongLines,getApiFunctionInfo,getApiMapping,getSuperClasses,hasProperty,isLocal,isLookupCandidate,isStateNode,lookupByFullName,lookupNext,lookupResultContains,lookupWithType,makeToyboxLink,mapVarDeclsByType,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
+0 && (module.exports = {checkCompilerVersion,collectNamespaces,createDocumentationMap,diagnostic,diagnosticHelper,findNamesInScope,findUsingForNode,formatAst,formatAstLongLines,getApiFunctionInfo,getApiMapping,getSuperClasses,hasProperty,isClassVariable,isLocal,isLookupCandidate,isStateNode,lookupByFullName,lookupNext,lookupResultContains,lookupWithType,makeToyboxLink,mapVarDeclsByType,markInvokeClassMethod,parseSdkVersion,sameLookupResult,traverseAst,variableDeclarationName,visitReferences,visit_resources,visitorNode});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -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, 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) {
@@ -2725,10 +2759,12 @@ function fixNodeScope(state, lookupNode, nodeStack) {
 /* harmony import */ var _type_flow_interp__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(7161);
 /* harmony import */ var _type_flow_optimize__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(3687);
 /* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(9234);
-/* harmony import */ var _unused_exprs__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(424);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(6906);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_15___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_15__);
-/* harmony import */ var _variable_renamer__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(4405);
+/* harmony import */ var _type_flow_types__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(7255);
+/* harmony import */ var _unused_exprs__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(424);
+/* 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 _variable_renamer__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(4405);
+
 
 
 
@@ -3175,12 +3211,19 @@ 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);
         if (result) {
             if (isExpression(result)) {
-                istate.stack[istate.stack.length - 1].node = result;
+                const elem = istate.stack[istate.stack.length - 1];
+                elem.node = result;
+                if (result.type === "Literal") {
+                    elem.value = typeFromLiteral(result);
+                    elem.embeddedEffects = false;
+                }
             }
             again = true;
         }
@@ -3270,7 +3313,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                         throw new Error(`While renaming ${declName} to ${name}: Didn't find original declaration`);
                     }
                 }
-                ident.name = name;
+                renameIdentifier(ident, name);
             }
             else {
                 map[declName] = true;
@@ -3330,7 +3373,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                     if (hasProperty(map, node.name)) {
                         const name = map[node.name];
                         if (typeof name === "string") {
-                            node.name = name;
+                            renameIdentifier(node, name);
                         }
                         const [, results] = state.lookupValue(node);
                         if (results) {
@@ -3365,7 +3408,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                         if (hasProperty(map, lhs.name)) {
                             const name = map[lhs.name];
                             if (typeof name === "string") {
-                                lhs.name = name;
+                                renameIdentifier(lhs, name);
                             }
                         }
                     }
@@ -3529,9 +3572,14 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
             }
             case "VariableDeclaration": {
                 const locals = topLocals();
-                if (locals.map &&
-                    locals.node &&
-                    locals.node.type === "BlockStatement") {
+                if (!locals.map) {
+                    if (again) {
+                        again = false;
+                        state.traverse(node);
+                    }
+                    break;
+                }
+                if (locals.node && locals.node.type === "BlockStatement") {
                     let results;
                     const declarations = node.declarations;
                     let i = 0;
@@ -3737,6 +3785,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
             return ret;
         });
     });
+    config.checkCompilerLookupRules = checkLookupRules;
     reportMissingSymbols(state, config);
     if (state.inlineDiagnostics) {
         if (!state.diagnostics) {
@@ -3799,6 +3848,7 @@ function optimizeCall(istate, node, context) {
             node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
             const ret = evaluateFunction(istate, callee, node.arguments);
             if (ret) {
+                inlineDiagnostic(state, callees[0], node, null);
                 return withLoc(ret, node, node);
             }
         }
@@ -3957,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();
@@ -4154,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);
@@ -4302,11 +4356,12 @@ const LocalRefCost = 2;
 function refCost(node) {
     if (node.type === "Literal") {
         switch (typeof node.value) {
+            case "bigint":
+                return 9;
             case "string":
                 return 5;
-            case "bigint":
             case "number":
-                return 5;
+                return node.raw.match(/d/i) ? 9 : 5;
             case "boolean":
                 return 2;
             default:
@@ -4802,26 +4857,32 @@ function applyReplacements(func, nodeMap, declMap) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "nK": () => (/* binding */ findObjectDeclsByProperty)
-/* harmony export */ });
-/* unused harmony exports missingNullWorkaround, buildTypeInfo, buildConflictGraph, resolveDottedMember */
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
-/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5101);
-/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8180);
-/* harmony import */ var _function_info__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(819);
-/* harmony import */ var _type_flow_dead_store__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(8486);
-/* harmony import */ var _type_flow_interp__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(7161);
-/* harmony import */ var _type_flow_interp_call__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(2222);
-/* harmony import */ var _type_flow_intersection_type__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(6973);
-/* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(9234);
-/* harmony import */ var _type_flow_type_flow_util__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(1638);
-/* harmony import */ var _type_flow_types__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(7255);
-/* harmony import */ var _type_flow_union_type__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(757);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(6906);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_13__);
+/* unused harmony exports missingNullWorkaround, buildTypeInfo, buildConflictGraph */
+/* 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 _function_info__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(819);
+/* 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__);
+
+
+
+
 
 
 
@@ -4857,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) {
@@ -4873,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) {
@@ -4980,36 +5050,205 @@ function intersectEquiv(ts1, ts2, k) {
     } while (s !== k);
     return ret;
 }
-function mergeTypeState(blockStates, blockVisits, index, from) {
+function clearAssocPaths(blockState, decl, v) {
+    if (v.assocPaths?.size) {
+        assert(blockState.trackedMemberDecls);
+        v.assocPaths.forEach((assocPath) => {
+            assocPath.split(".").forEach((pathItem) => {
+                const tmd = blockState.trackedMemberDecls?.get(pathItem);
+                if (tmd) {
+                    tmd.delete(decl);
+                }
+            });
+        });
+    }
+}
+function cloneTypeState(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 Set(value));
+        });
+    }
+    if (liveCopyPropEvents) {
+        clone.liveCopyPropEvents = new Map();
+        liveCopyPropEvents.forEach((value, key) => {
+            clone.liveCopyPropEvents?.set(key, new Set(value));
+        });
+    }
+    return clone;
+}
+function addTrackedMemberDecl(blockState, key, assocKey) {
+    if (!blockState.trackedMemberDecls) {
+        blockState.trackedMemberDecls = new Map();
+    }
+    assocKey.split(".").forEach((pathItem) => {
+        const entries = blockState.trackedMemberDecls.get(pathItem);
+        if (!entries) {
+            blockState.trackedMemberDecls.set(pathItem, new Set([key]));
+            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);
+        }
+    });
+}
+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] = new Map(from);
-        blockVisits[index] = 1;
+        blockStates[index] = cloneTypeState(from);
+        blockStates[index].visits = 1;
         return true;
     }
-    const widen = ++blockVisits[index] > 10;
+    const widen = ++to.visits > 10;
+    // we'll rebuild these from scratch
+    delete to.trackedMemberDecls;
+    delete to.liveCopyPropEvents;
     let changes = false;
-    to.forEach((tov, k) => {
-        const fromv = from.get(k);
+    to.map.forEach((tov, k) => {
+        const fromv = from.map.get(k);
         if (!fromv) {
             changes = true;
             if (tov.equivSet) {
-                removeEquiv(to, k);
+                removeEquiv(to.map, k);
             }
-            to.delete(k);
+            to.map.delete(k);
             return;
         }
         if (tov.equivSet) {
-            if (intersectEquiv(to, from, k)) {
+            if (intersectEquiv(to.map, from.map, k)) {
+                changes = true;
+                tov = to.map.get(k);
+            }
+        }
+        if (tov.assocPaths) {
+            tov = { ...tov };
+            if (!fromv.assocPaths) {
+                changes = true;
+                delete tov.assocPaths;
+            }
+            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);
+                    }
+                });
+                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;
-                tov = to.get(k);
+                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;
             if (subtypeOf(tov.curType, fromv.curType)) {
-                to.set(k, { ...tov, curType: fromv.curType });
+                to.map.set(k, { ...tov, curType: fromv.curType });
                 changes = true;
                 return;
             }
@@ -5022,7 +5261,7 @@ function mergeTypeState(blockStates, blockVisits, index, from) {
             if (wide)
                 result = wide;
         }
-        to.set(k, { ...tov, curType: result });
+        to.map.set(k, { ...tov, curType: result });
         changes = true;
     });
     return changes;
@@ -5033,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(", ")})]`;
@@ -5049,149 +5286,105 @@ function printBlockState(block, state, indent = "") {
         console.log(indent + "Not visited!");
         return;
     }
-    state.forEach((value, key) => {
-        console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet ? " " + tsEquivs(state, key) : ""}`);
+    state.map.forEach((value, key) => {
+        console.log(`${indent} - ${typeStateEntry(value, key)}${value.equivSet ? " " + tsEquivs(state.map, key) : ""}`);
     });
 }
-/*
- * We have an object, and a MemberExpression object.<name>
- *  - decls are the StateNodes associated with the known type
- *    of object.
- *  - possible are all the StateNodes that declare <name>
- *
- * We want to find all the elements of possible which are
- * "compatible" with decls, which tells us the set of things
- * that object.<name> could correspond to, and also what that
- * tells us about object.
- *
- * The return value is two arrays of StateNode. The first
- * gives the refined type of object, and the second is the
- * array of StateNodes that could declare <name>
- */
-function filterDecls(decls, possible, name) {
-    if (!possible)
-        return [null, null];
-    const result = decls.reduce((cur, decl) => {
-        const found = possible.reduce((flag, poss) => {
-            if (decl === poss ||
-                (poss.type === "ClassDeclaration" && (0,_api__WEBPACK_IMPORTED_MODULE_0__.getSuperClasses)(poss)?.has(decl))) {
-                // poss extends decl, so decl must actually be a poss
-                // eg we know obj is an Object, and we call obj.toNumber
-                // so possible includes all the classes that declare toNumber
-                // so we can refine obj's type to the union of those types
-                if (!cur[0]) {
-                    cur = [new Set(), new Set()];
-                }
-                cur[0].add(poss);
-                cur[1].add(poss);
-                return true;
+function updateAffected(blockState, objectType, baseDecl, assignedPath, affectedName, affected, assignedType) {
+    affected.forEach((key) => {
+        let droppedComponents = null;
+        const entry = blockState.map.get(key);
+        assert(entry && entry.assocPaths);
+        let newEntry = entry;
+        entry.assocPaths.forEach((path) => {
+            if (key === baseDecl && path === assignedPath) {
+                return;
             }
-            else if (decl.type === "ClassDeclaration" &&
-                (0,_api__WEBPACK_IMPORTED_MODULE_0__.getSuperClasses)(decl)?.has(poss)) {
-                // decl extends poss, so decl remains unchanged
-                // eg we know obj is Menu2, we call obj.toString
-                // Menu2 doesn't define toString, but Object does
-                // so poss is Object. But we still know that
-                // obj is Menu2
-                if (!cur[0]) {
-                    cur = [new Set(), new Set()];
-                }
-                cur[0].add(decl);
-                cur[1].add(poss);
-                return true;
+            const pathSegments = path.split(".");
+            if (!pathSegments.includes(affectedName)) {
+                return;
             }
-            return flag;
-        }, false);
-        if (!found) {
-            // If we didn't find the property in any of the
-            // standard places, the runtime might still find
-            // it by searching up the Module stack (and up
-            // the module stack from any super classes)
-            //
-            // eg
-            //
-            //  obj = Application.getApp();
-            //  obj.Properties.whatever
-            //
-            // Properties doesn't exist on AppBase, but AppBase
-            // is declared in Application, and Application
-            // does declare Properties. So Application.Properties
-            // is (one of) the declarations we should find; but we
-            // must not refine obj's type to include Application.
-            let d = [decl];
-            do {
-                d.forEach((d) => {
-                    const stack = d.stack;
-                    possible.forEach((poss) => {
-                        for (let i = stack.length; i--;) {
-                            const sn = stack[i].sn;
-                            if (sn.decls === poss.decls) {
-                                if (!cur[0]) {
-                                    cur = [new Set(), new Set()];
-                                }
-                                cur[0].add(decl);
-                                cur[1].add(poss);
-                                break;
-                            }
-                            if ((0,_api__WEBPACK_IMPORTED_MODULE_0__.hasProperty)(sn.decls, name)) {
-                                break;
-                            }
-                        }
-                    });
+            const assocPath = [];
+            let type = entry.curType;
+            for (let i = 0; i < pathSegments.length; i++) {
+                const pathItem = pathSegments[i];
+                assocPath.push({
+                    name: pathItem === "*" ? null : pathItem,
+                    type,
                 });
-                d = d.flatMap((d) => {
-                    if (d.type !== "ClassDeclaration" ||
-                        !d.superClass ||
-                        d.superClass === true) {
-                        return [];
+                if (pathItem === affectedName && couldBeShallow(type, objectType)) {
+                    const newAssocKey = assocPath.map((av) => av.name ?? "*").join(".");
+                    if (newEntry === entry) {
+                        newEntry = { ...entry };
+                    }
+                    if (newAssocKey !== path) {
+                        newEntry.assocPaths = new Set(newEntry.assocPaths);
+                        newEntry.assocPaths.delete(path);
+                        // 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;
                     }
-                    return d.superClass;
-                });
-            } while (d.length);
+                    const baseType = updateByAssocPath(assocPath, assignedType, true);
+                    newEntry.curType = baseType;
+                    break;
+                }
+                if (pathItem === "*") {
+                    const newType = { type: 0 /* TypeTag.Never */ };
+                    if (type.type & 512 /* TypeTag.Array */) {
+                        const atype = getUnionComponent(type, 512 /* TypeTag.Array */);
+                        if (atype) {
+                            unionInto(newType, atype);
+                        }
+                    }
+                    if (type.type & 1024 /* TypeTag.Dictionary */) {
+                        const dtype = getUnionComponent(type, 1024 /* TypeTag.Dictionary */);
+                        if (dtype) {
+                            unionInto(newType, dtype.value);
+                        }
+                    }
+                    if (newType.type === 0 /* TypeTag.Never */)
+                        break;
+                    type = newType;
+                }
+                else {
+                    const objValue = getObjectValue(type);
+                    if (!objValue || !hasProperty(objValue.obj, pathItem)) {
+                        break;
+                    }
+                    type = objValue.obj[pathItem];
+                }
+            }
+        });
+        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);
         }
-        return cur;
-    }, [null, null]);
-    if (!result[0])
-        return [null, null];
-    return [Array.from(result[0]), Array.from(result[1])];
-}
-function findObjectDeclsByProperty(state, object, next) {
-    const decls = (0,_type_flow_types__WEBPACK_IMPORTED_MODULE_11__/* .getStateNodeDeclsFromType */ .iX)(state, object);
-    if (!decls)
-        return [null, null];
-    const possibleDecls = (0,_api__WEBPACK_IMPORTED_MODULE_0__.hasProperty)(state.allDeclarations, next.property.name) &&
-        state.allDeclarations[next.property.name];
-    return filterDecls(decls, possibleDecls, next.property.name);
-}
-function refineObjectTypeByDecls(istate, object, trueDecls) {
-    const refinedType = typeFromTypeStateNodes(istate.state, trueDecls);
-    return intersection(object, refinedType);
-}
-function findNextObjectType(istate, trueDecls, next) {
-    const results = lookupNext(istate.state, [{ parent: null, results: trueDecls }], "decls", next.property);
-    if (!results)
-        return null;
-    return results.reduce((cur, lookupDefn) => {
-        unionInto(cur, typeFromTypeStateNodes(istate.state, lookupDefn.results));
-        return cur;
-    }, { type: 0 /* TypeTag.Never */ });
-}
-function resolveDottedMember(istate, object, next) {
-    const [objDecls, trueDecls] = findObjectDeclsByProperty(istate.state, object, next);
-    if (!objDecls)
-        return null;
-    const property = findNextObjectType(istate, trueDecls, next);
-    if (!property)
-        return null;
-    const type = refineObjectTypeByDecls(istate, object, objDecls);
-    const mayThrow = !subtypeOf(object, type);
-    return { mayThrow, object: type, property };
+    });
 }
-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();
     const queue = new DataflowQueue();
+    let selfClassDecl = null;
+    if (!(func.attributes & StateNodeAttributes.STATIC)) {
+        const klass = func.stack?.[func.stack?.length - 1].sn;
+        if (klass && klass.type === "ClassDeclaration") {
+            selfClassDecl = klass;
+        }
+    }
     order.forEach((block, i) => {
         block.order = i;
     });
@@ -5202,10 +5395,10 @@ 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;
+        let next = null;
         let updateAny = false;
         for (let i = 0, l = decl.path.length - 1; i <= l; i++) {
             let cur = typePath.pop();
@@ -5276,55 +5469,62 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             typePath.push(cur);
             typePath.push(next);
         }
-        for (let i = decl.path.length; i--;) {
-            const me = decl.path[i];
-            const property = typePath.pop();
-            let object = typePath.pop();
-            if (!me.computed) {
-                const value = getObjectValue(object);
-                if (value) {
-                    if (value.obj && hasProperty(value.obj, me.property.name)) {
-                        const prevProp = value.obj[me.property.name];
-                        if (!subtypeOf(prevProp, property)) {
-                            object = cloneType(object);
-                            const newValue = { klass: value.klass, obj: { ...value.obj } };
-                            newValue.obj[me.property.name] = intersection(prevProp, property);
-                            setUnionComponent(object, 32768 /* TypeTag.Object */, newValue);
+        const assocValue = decl.path.map((me, i) => ({
+            name: me.computed ? null : me.property.name,
+            type: typePath[i],
+        }));
+        const assocKey = assocValue.map((av) => av.name ?? "*").join(".");
+        const newType = updateByAssocPath(assocValue, next, false);
+        setStateEvent(blockState, decl.base, newType, newValue ? 1 /* UpdateKind.Inner */ : 0 /* UpdateKind.None */);
+        const tsv = { ...blockState.map.get(decl.base) };
+        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];
+            if (baseElem.name) {
+                const affected = blockState.trackedMemberDecls?.get(baseElem.name);
+                if (affected) {
+                    updateAffected(blockState, baseElem.type, decl.base, assocKey, baseElem.name, affected, next);
+                }
+            }
+            if (selfClassDecl) {
+                // Handle interference between the MemberDecl store
+                // and the "self" object.
+                const baseObj = getObjectValue(baseElem.type);
+                if (baseObj &&
+                    baseObj.klass.type === 16384 /* TypeTag.Class */ &&
+                    some(baseObj.klass.value, (cls) => cls === selfClassDecl ||
+                        getSuperClasses(cls)?.has(selfClassDecl) ||
+                        getSuperClasses(selfClassDecl)?.has(cls) ||
+                        false)) {
+                    const last = decl.path[decl.path.length - 1];
+                    if (!last.computed) {
+                        const result = lookupNext(state, [{ parent: null, results: [selfClassDecl] }], "decls", last.property);
+                        if (result) {
+                            const decls = result.flatMap((lookupDef) => lookupDef.results);
+                            const doUpdate = (key, cur) => {
+                                const update = cloneType(cur.curType);
+                                unionInto(update, next);
+                                setStateEvent(blockState, key, update, 0 /* UpdateKind.None */);
+                            };
+                            if (decls.length === 1) {
+                                const cur = blockState.map.get(decls[0]);
+                                cur && doUpdate(decls[0], cur);
+                            }
+                            else {
+                                blockState.map.forEach((cur, key) => {
+                                    if (Array.isArray(key) && key[0] === decls[0]) {
+                                        doUpdate(key, cur);
+                                    }
+                                });
+                            }
                         }
                     }
-                    else {
-                        const obj = value.obj ? { ...value.obj } : {};
-                        obj[me.property.name] = property;
-                        object = cloneType(object);
-                        setUnionComponent(object, 32768 /* TypeTag.Object */, {
-                            klass: value.klass,
-                            obj,
-                        });
-                    }
-                }
-            }
-            else {
-                if (object.type & 512 /* TypeTag.Array */) {
-                    const avalue = getUnionComponent(object, 512 /* TypeTag.Array */);
-                    if (!avalue || !subtypeOf(property, avalue)) {
-                        object = cloneType(object);
-                        setUnionComponent(object, 512 /* TypeTag.Array */, property);
-                    }
-                }
-                if (object.type & 1024 /* TypeTag.Dictionary */) {
-                    const dvalue = getUnionComponent(object, 1024 /* TypeTag.Dictionary */);
-                    if (!dvalue || !subtypeOf(property, dvalue.value)) {
-                        object = cloneType(object);
-                        setUnionComponent(object, 1024 /* TypeTag.Dictionary */, {
-                            key: dvalue?.key || { type: 524287 /* TypeTag.Any */ },
-                            value: property,
-                        });
-                    }
                 }
             }
-            typePath.push(object);
         }
-        setStateEvent(blockState, decl.base, typePath[0], false);
         return [next, updateAny];
     }
     function typeConstraint(decls) {
@@ -5341,38 +5541,61 @@ 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")) {
-            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
                  */
-                const v = blockState.get(decl);
+                const v = blockState.map.get(decl);
                 if (v?.equivSet) {
                     let s = decl;
                     do {
-                        const next = blockState.get(s);
+                        const next = blockState.map.get(s);
                         if (!next || !next.equivSet) {
                             throw new Error(`Inconsistent equivSet for ${tsKey(decl)}: missing value for ${tsKey(s)}`);
                         }
-                        blockState.set(s, { ...next, curType: value });
+                        blockState.map.set(s, { ...next, curType: value });
                         s = next.equivSet.next;
                     } while (s !== decl);
-                    return;
+                }
+                else {
+                    blockState.map.set(decl, { ...v, curType: value });
                 }
             }
             else {
-                removeEquiv(blockState, decl);
+                const v = blockState.map.get(decl);
+                removeEquiv(blockState.map, decl);
+                if (v?.assocPaths?.size) {
+                    clearAssocPaths(blockState, decl, v);
+                }
+                if (v?.copyPropItem) {
+                    copyPropFailed(blockState, v.copyPropItem, nodeCopyProp);
+                }
+                blockState.map.set(decl, { curType: value });
             }
-            blockState.set(decl, { curType: value });
             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;
@@ -5380,21 +5603,20 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
     function getStateEntry(blockState, decl) {
         if (Array.isArray(decl) ||
             (decl.type !== "MemberDecl" && decl.type !== "Unknown")) {
-            let tsVal = blockState.get(decl);
+            let tsVal = blockState.map.get(decl);
             if (!tsVal) {
                 tsVal = { curType: typeConstraint(decl) };
-                blockState.set(decl, tsVal);
+                blockState.map.set(decl, tsVal);
             }
             return tsVal;
         }
         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 = [];
-    const blockVisits = [];
     const typeMap = new Map();
     const istate = {
         state,
@@ -5412,23 +5634,58 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             if (succ.order == null) {
                 throw new Error("Unreachable block was visited");
             }
-            if (mergeTypeState(blockStates, blockVisits, 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) => {
@@ -5447,8 +5704,8 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         return false;
                     }
                 }
-                const tmpState = new Map(curState);
-                setStateEvent(tmpState, leftDecl, leftr, false);
+                const tmpState = cloneTypeState(curState);
+                setStateEvent(tmpState, leftDecl, leftr, 0 /* UpdateKind.None */);
                 if (rightDecl) {
                     let rightr = restrictByEquality(left, right);
                     if (rightr.type === 0 /* TypeTag.Never */) {
@@ -5460,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;
             }
@@ -5473,8 +5730,8 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 singletonRemoved.type -= right.type;
                 if (singletonRemoved.type === 0 /* TypeTag.Never */)
                     return false;
-                const tmpState = new Map(curState);
-                setStateEvent(tmpState, leftDecl, singletonRemoved, false);
+                const tmpState = cloneTypeState(curState);
+                setStateEvent(tmpState, leftDecl, singletonRemoved, 0 /* UpdateKind.None */);
                 return tmpState;
             }
             return null;
@@ -5505,8 +5762,8 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                             singletonRemoved.type &= ~(1 /* TypeTag.Null */ | 2 /* TypeTag.False */);
                             if (singletonRemoved.type === 0 /* TypeTag.Never */)
                                 return false;
-                            const tmpState = new Map(curState);
-                            setStateEvent(tmpState, event.left, singletonRemoved, false);
+                            const tmpState = cloneTypeState(curState);
+                            setStateEvent(tmpState, event.left, singletonRemoved, 0 /* UpdateKind.None */);
                             return tmpState;
                         }
                     }
@@ -5520,8 +5777,8 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         });
                         if (nonNullRemoved.type === 0 /* TypeTag.Never */)
                             return false;
-                        const tmpState = new Map(curState);
-                        setStateEvent(tmpState, event.left, nonNullRemoved, false);
+                        const tmpState = cloneTypeState(curState);
+                        setStateEvent(tmpState, event.left, nonNullRemoved, 0 /* UpdateKind.None */);
                         return tmpState;
                     }
                     break;
@@ -5578,8 +5835,8 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         }
                     }
                     if (result) {
-                        const tmpState = new Map(curState);
-                        setStateEvent(tmpState, event.left, result, false);
+                        const tmpState = cloneTypeState(curState);
+                        setStateEvent(tmpState, event.left, result, 0 /* UpdateKind.None */);
                         return tmpState;
                     }
                 }
@@ -5606,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, blockVisits, 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);
             }
         }
@@ -5618,37 +5878,55 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 console.log(`  Flow (false): merge to: ${falseSucc.order || -1}`);
                 printBlockState(top, sFalse || curState, "    >false ");
             }
-            if (mergeTypeState(blockStates, blockVisits, 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, blockVisits, 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);
                 if (curEntry.equivSet) {
-                    removeEquiv(curState, event.decl);
+                    removeEquiv(curState.map, event.decl);
                 }
-                curState.delete(event.decl);
+                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) {
-                    const equiv = Array.from(getEquivSet(curState, event.decl)).filter((decl) => decl !== event.decl && declIsLocal(decl));
+                    const equiv = Array.from(getEquivSet(curState.map, event.decl)).filter((decl) => decl !== event.decl && declIsLocal(decl));
                     if (equiv.length) {
                         nodeEquivs.set(event.node, {
                             decl: event.decl,
@@ -5656,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)}`);
                 }
@@ -5665,44 +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);
+                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 */);
+                        }
                     }
-                }
-                if (callees === undefined && event.callees !== undefined) {
-                    callees = event.callees;
-                }
-                if (event.calleeObj) {
-                    if (handleMod(curState, event.calleeObj, callees, event.node)) {
-                        break;
+                    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);
+                            }
+                        });
                     }
-                }
-                curState.forEach((tsv, decl) => {
-                    let type = tsv.curType;
-                    if (callees === undefined || modifiableDecl(decl, callees)) {
-                        if (tsv.equivSet) {
-                            removeEquiv(curState, 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;
                         }
-                        curState.set(decl, { curType: typeConstraint(decl) });
-                    }
-                    else if (type.value != null &&
-                        !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.set(decl, { ...tsv, curType: type });
+                        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) });
                         }
-                    }
+                        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;
             }
@@ -5713,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"
@@ -5724,24 +6062,47 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 const type = expr
                     ? evaluate(istate, expr).value
                     : { type: 524287 /* TypeTag.Any */ };
-                if (setStateEvent(curState, event.decl, type, true)) {
-                    // we wrote through a computed member expression
-                    // which might have been a Class, Module or Object.
-                    // That could have affected anything...
-                    curState.forEach((value, decls) => {
+                const wasComputedDecl = setStateEvent(curState, event.decl, type, 2 /* UpdateKind.Reassign */);
+                some(event.decl, (decl) => {
+                    if (decl.type !== "VariableDeclarator" ||
+                        decl.node.kind !== "var" ||
+                        !isClassVariable(decl)) {
+                        return false;
+                    }
+                    // A write to a class variable could interfere with
+                    // a MemberDecl
+                    const affected = curState.trackedMemberDecls?.get(decl.name);
+                    if (affected) {
+                        const objType = typeFromTypeStateNodes(istate.state, map(event.decl, (decl) => decl.type === "VariableDeclarator" &&
+                            decl.stack[decl.stack.length - 1].sn).filter((decl) => decl && decl.type === "ClassDeclaration"));
+                        updateAffected(curState, objType, event.decl, decl.name, decl.name, affected, type);
+                    }
+                    return true;
+                });
+                if (wasComputedDecl) {
+                    curState.map.forEach((value, decls) => {
+                        // we wrote through a computed member expression
+                        // which might have been a Class, Module or Object.
+                        // That could have affected any non-local...
                         if (some(decls, (decl) => decl.type === "VariableDeclarator" &&
                             decl.node.kind === "var" &&
                             !isLocal(decl))) {
                             if (value.equivSet) {
-                                removeEquiv(curState, decls);
+                                removeEquiv(curState.map, decls);
                             }
-                            curState.set(decls, { curType: typeConstraint(decls) });
+                            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, event.rhs, event.decl);
-                    if (event.node.type === "AssignmentExpression") {
+                    const selfAssign = addEquiv(curState.map, event.rhs, event.decl);
+                    if (event.node.type === "AssignmentExpression" &&
+                        event.node.operator === "=") {
                         if (selfAssign) {
                             // rhs and lhs are identical
                             selfAssignments.add(event.node);
@@ -5751,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) {
@@ -5759,7 +6185,8 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                     }
                     else {
                         locals.forEach((local) => {
-                            if (local !== event.decl && curState.has(local)) {
+                            if (local !== event.decl &&
+                                curState.map.has(local)) {
                                 localConflicts.add(local);
                             }
                         });
@@ -5780,7 +6207,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 }
                 if (logThisRun) {
                     console.log(`  ${describeEvent(event)} : ${!Array.isArray(event.left) && event.left.type === "MemberDecl"
-                        ? `${display(curState.get(event.left.base)?.curType || {
+                        ? `${display(curState.map.get(event.left.base)?.curType || {
                             type: 524287 /* TypeTag.Any */,
                         })} :: `
                         : ""}${display(getStateType(curState, event.left))}`);
@@ -5792,13 +6219,13 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
         }
         return false;
     };
-    blockStates[0] = new Map();
+    blockStates[0] = { map: new Map(), visits: 0 };
     const head = blockStates[0];
     // set the parameters to their initial types
     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()) {
@@ -5808,7 +6235,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
         }
         if (!blockStates[top.order])
             continue;
-        const curState = new Map(blockStates[top.order]);
+        const curState = cloneTypeState(blockStates[top.order]);
         if (logThisRun) {
             printBlockHeader(top);
             printBlockState(top, curState);
@@ -5832,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);
@@ -5849,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) {
@@ -5895,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;
@@ -5952,7 +6457,62 @@ 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) => {
+        const clone = cloneType(base);
+        unionInto(clone, property);
+        return clone;
+    };
+    for (let i = path.length; i--;) {
+        const pathElem = path[i];
+        let object = pathElem.type;
+        if (pathElem.name) {
+            const value = getObjectValue(object);
+            if (value) {
+                const obj = value.obj ? { ...value.obj } : {};
+                obj[pathElem.name] = union
+                    ? valueToStore(obj[pathElem.name] || { type: 524287 /* TypeTag.Any */ })
+                    : property;
+                object = cloneType(object);
+                setUnionComponent(object, 32768 /* TypeTag.Object */, {
+                    klass: value.klass,
+                    obj,
+                });
+            }
+        }
+        else {
+            if (object.type & 512 /* TypeTag.Array */) {
+                object = cloneType(object);
+                setUnionComponent(object, 512 /* TypeTag.Array */, union
+                    ? valueToStore(getUnionComponent(object, 512 /* TypeTag.Array */) || {
+                        type: 524287 /* TypeTag.Any */,
+                    })
+                    : property);
+            }
+            if (object.type & 1024 /* TypeTag.Dictionary */) {
+                const dvalue = getUnionComponent(object, 1024 /* TypeTag.Dictionary */);
+                object = cloneType(object);
+                setUnionComponent(object, 1024 /* TypeTag.Dictionary */, {
+                    key: dvalue?.key || { type: 524287 /* TypeTag.Any */ },
+                    value: union
+                        ? valueToStore(getUnionComponent(object, 1024 /* TypeTag.Dictionary */)?.value || {
+                            type: 524287 /* TypeTag.Any */,
+                        })
+                        : property,
+                });
+            }
+        }
+        path[i].type = object;
+        property = object;
+        union = false;
+    }
+    return property;
 }
 
 
@@ -5962,7 +6522,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* unused harmony exports couldBe, couldBeWeak */
+/* unused harmony exports couldBeHelper, couldBe, couldBeWeak, couldBeShallow */
 /* 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);
@@ -5980,7 +6540,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
  * This is symmetric, and a subtypeOf b, or b subtypeOf a implies
  * a couldBe b.
  */
-function couldBe(a, b) {
+function couldBeHelper(a, b, shallow) {
     const common = a.type & b.type & ~262144 /* TypeTag.Typedef */;
     if (common) {
         if (a.value == null || b.value == null || a.value === b.value) {
@@ -6000,7 +6560,7 @@ function couldBe(a, b) {
             const bvalue = getUnionComponent(b, ac.type);
             if (bvalue == null ||
                 ac.value === bvalue ||
-                couldBeValue({ type: ac.type, avalue: ac.value, bvalue })) {
+                couldBeValue({ type: ac.type, avalue: ac.value, bvalue }, shallow)) {
                 result = true;
                 return false;
             }
@@ -6050,12 +6610,19 @@ function couldBe(a, b) {
     }
     return false;
 }
+function couldBe(a, b) {
+    return couldBeHelper(a, b, false);
+}
 function couldBeWeak(a, b) {
     if (a.type === 0 /* TypeTag.Never */ || b.type === 0 /* TypeTag.Never */)
         return true;
     return couldBe(a, b);
 }
-function couldBeValue(pair) {
+//
+function couldBeShallow(a, b) {
+    return couldBeHelper(a, b, true);
+}
+function couldBeValue(pair, shallow) {
     switch (pair.type) {
         case 1 /* TypeTag.Null */:
         case 2 /* TypeTag.False */:
@@ -6071,10 +6638,11 @@ function couldBeValue(pair) {
         case 131072 /* TypeTag.Symbol */:
             return pair.avalue === pair.bvalue;
         case 512 /* TypeTag.Array */:
-            return couldBe(pair.avalue, pair.bvalue);
+            return shallow || couldBe(pair.avalue, pair.bvalue);
         case 1024 /* TypeTag.Dictionary */: {
-            return (couldBe(pair.avalue.key, pair.bvalue.key) &&
-                couldBe(pair.avalue.value, pair.bvalue.value));
+            return (shallow ||
+                (couldBe(pair.avalue.key, pair.bvalue.key) &&
+                    couldBe(pair.avalue.value, pair.bvalue.value)));
         }
         case 2048 /* TypeTag.Method */: {
             return (pair.avalue.args.length === pair.bvalue.args.length &&
@@ -6100,7 +6668,7 @@ function couldBeValue(pair) {
         }
         case 32768 /* TypeTag.Object */: {
             return (couldBe(pair.avalue.klass, pair.bvalue.klass) &&
-                couldBeObj(pair.avalue.obj, pair.bvalue.obj));
+                (shallow || couldBeObj(pair.avalue.obj, pair.bvalue.obj)));
         }
         case 65536 /* TypeTag.Enum */: {
             return (pair.avalue.enum === pair.bvalue.enum &&
@@ -6130,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;
@@ -6151,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
@@ -6168,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()) {
@@ -6182,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--;) {
@@ -6200,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);
@@ -6235,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)}`);
                                 }
@@ -6247,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;
@@ -6264,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)) {
@@ -6296,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) => {
@@ -6367,7 +7048,7 @@ function eliminateDeadStores(state, func, graph, logThisRun) {
         }
         return null;
     });
-    return changes;
+    return { copyPropStores, changes };
 }
 
 
@@ -6378,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);
+
+
 
 
 
@@ -6711,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: () => ({
@@ -6729,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 */ };
@@ -6787,15 +7479,15 @@ function evaluateLogicalTypes(op, left, right) {
 "use strict";
 /* unused harmony exports evaluateCall, checkCallArgs, sysCallInfo */
 /* harmony import */ var _optimizer_types__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9697);
-/* harmony import */ var _type_flow__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4859);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6817);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6906);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _interp__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(7161);
-/* harmony import */ var _sub_type__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9234);
-/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(7255);
-/* harmony import */ var _union_type__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(757);
+/* 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 _util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _interp__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7161);
+/* harmony import */ var _sub_type__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(9234);
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7255);
+/* harmony import */ var _union_type__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(757);
+/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(1638);
 
 
 
@@ -6851,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)
@@ -6982,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 */) {
@@ -7211,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,
@@ -7254,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;
 }
 
 
@@ -7270,11 +8005,11 @@ function getSystemCallTable() {
 /* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
 /* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8180);
 /* harmony import */ var _optimizer_types__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9697);
-/* harmony import */ var _type_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4859);
-/* harmony import */ var _could_be__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4055);
-/* harmony import */ var _interp_binary__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(4706);
-/* harmony import */ var _interp_call__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(2222);
-/* harmony import */ var _sub_type__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(9234);
+/* harmony import */ var _could_be__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4055);
+/* harmony import */ var _interp_binary__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4706);
+/* harmony import */ var _interp_call__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(2222);
+/* harmony import */ var _sub_type__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(9234);
+/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(1638);
 /* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(7255);
 /* harmony import */ var _union_type__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(757);
 
@@ -8610,12 +9345,14 @@ function restrictByEquality(a, b) {
 /* unused harmony export minimizeLocals */
 /* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4143);
 /* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(node_assert__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5101);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6817);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6652);
+/* harmony import */ var _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 _type_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4859);
-/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(1638);
+/* harmony import */ var _variable_renamer__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4405);
+/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1638);
+
 
 
 
@@ -8763,8 +9500,7 @@ function minimizeLocals(state, func) {
         switch (node.type) {
             case "Identifier":
                 if (info && info.name !== node.name) {
-                    node.original = node.name;
-                    node.name = info.name;
+                    renameIdentifier(node, info.name);
                 }
                 return null;
             case "AssignmentExpression":
@@ -8775,8 +9511,7 @@ function minimizeLocals(state, func) {
                         return withLoc({ type: "Literal", value: null, raw: "null" }, node, node);
                     }
                     if (node.left.name !== info.name) {
-                        node.left.original = node.left.name;
-                        node.left.name = info.name;
+                        renameIdentifier(node.left, info.name);
                     }
                     return null;
                 }
@@ -8790,8 +9525,7 @@ function minimizeLocals(state, func) {
                 if (info) {
                     assert(node.argument.type === "Identifier");
                     if (node.argument.name !== info.name) {
-                        node.argument.original = node.argument.name;
-                        node.argument.name = info.name;
+                        renameIdentifier(node.argument, info.name);
                     }
                     return null;
                 }
@@ -8934,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);
@@ -9679,12 +10431,23 @@ function subtypeOfObj(a, b) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* unused harmony exports isTypeStateKey, declIsLocal, localDeclName, tsKey, sourceLocation, printBlockHeader, describeEvent, printBlockEvents, printBlockTrailer */
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "nK": () => (/* binding */ findObjectDeclsByProperty)
+/* harmony export */ });
+/* 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);
 /* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6906);
 /* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _intersection_type__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6973);
+/* harmony import */ var _sub_type__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(9234);
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7255);
+/* harmony import */ var _union_type__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(757);
+
+
+
+
 
 
 
@@ -9697,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];
@@ -9761,6 +10527,140 @@ function printBlockTrailer(block) {
         .map((block) => block.order)
         .join(", ")} ExSucc: ${block.exsucc ? block.exsucc.order : ""}`);
 }
+/*
+ * We have an object, and a MemberExpression object.<name>
+ *  - decls are the StateNodes associated with the known type
+ *    of object.
+ *  - possible are all the StateNodes that declare <name>
+ *
+ * We want to find all the elements of possible which are
+ * "compatible" with decls, which tells us the set of things
+ * that object.<name> could correspond to, and also what that
+ * tells us about object.
+ *
+ * The return value is two arrays of StateNode. The first
+ * gives the refined type of object, and the second is the
+ * array of StateNodes that could declare <name>
+ */
+function filterDecls(decls, possible, name) {
+    if (!possible)
+        return [null, null];
+    const result = decls.reduce((cur, decl) => {
+        const found = possible.reduce((flag, poss) => {
+            if (decl === poss ||
+                (poss.type === "ClassDeclaration" && (0,_api__WEBPACK_IMPORTED_MODULE_0__.getSuperClasses)(poss)?.has(decl))) {
+                // poss extends decl, so decl must actually be a poss
+                // eg we know obj is an Object, and we call obj.toNumber
+                // so possible includes all the classes that declare toNumber
+                // so we can refine obj's type to the union of those types
+                if (!cur[0]) {
+                    cur = [new Set(), new Set()];
+                }
+                cur[0].add(poss);
+                cur[1].add(poss);
+                return true;
+            }
+            else if (decl.type === "ClassDeclaration" &&
+                (0,_api__WEBPACK_IMPORTED_MODULE_0__.getSuperClasses)(decl)?.has(poss)) {
+                // decl extends poss, so decl remains unchanged
+                // eg we know obj is Menu2, we call obj.toString
+                // Menu2 doesn't define toString, but Object does
+                // so poss is Object. But we still know that
+                // obj is Menu2
+                if (!cur[0]) {
+                    cur = [new Set(), new Set()];
+                }
+                cur[0].add(decl);
+                cur[1].add(poss);
+                return true;
+            }
+            return flag;
+        }, false);
+        if (!found) {
+            // If we didn't find the property in any of the
+            // standard places, the runtime might still find
+            // it by searching up the Module stack (and up
+            // the module stack from any super classes)
+            //
+            // eg
+            //
+            //  obj = Application.getApp();
+            //  obj.Properties.whatever
+            //
+            // Properties doesn't exist on AppBase, but AppBase
+            // is declared in Application, and Application
+            // does declare Properties. So Application.Properties
+            // is (one of) the declarations we should find; but we
+            // must not refine obj's type to include Application.
+            let d = [decl];
+            do {
+                d.forEach((d) => {
+                    const stack = d.stack;
+                    possible.forEach((poss) => {
+                        for (let i = stack.length; i--;) {
+                            const sn = stack[i].sn;
+                            if (sn.decls === poss.decls) {
+                                if (!cur[0]) {
+                                    cur = [new Set(), new Set()];
+                                }
+                                cur[0].add(decl);
+                                cur[1].add(poss);
+                                break;
+                            }
+                            if ((0,_api__WEBPACK_IMPORTED_MODULE_0__.hasProperty)(sn.decls, name)) {
+                                break;
+                            }
+                        }
+                    });
+                });
+                d = d.flatMap((d) => {
+                    if (d.type !== "ClassDeclaration" ||
+                        !d.superClass ||
+                        d.superClass === true) {
+                        return [];
+                    }
+                    return d.superClass;
+                });
+            } while (d.length);
+        }
+        return cur;
+    }, [null, null]);
+    if (!result[0])
+        return [null, null];
+    return [Array.from(result[0]), Array.from(result[1])];
+}
+function findObjectDeclsByProperty(state, object, next) {
+    const decls = (0,_types__WEBPACK_IMPORTED_MODULE_5__/* .getStateNodeDeclsFromType */ .iX)(state, object);
+    if (!decls)
+        return [null, null];
+    const possibleDecls = (0,_api__WEBPACK_IMPORTED_MODULE_0__.hasProperty)(state.allDeclarations, next.property.name) &&
+        state.allDeclarations[next.property.name];
+    return filterDecls(decls, possibleDecls, next.property.name);
+}
+function refineObjectTypeByDecls(istate, object, trueDecls) {
+    const refinedType = typeFromTypeStateNodes(istate.state, trueDecls);
+    return intersection(object, refinedType);
+}
+function findNextObjectType(istate, trueDecls, next) {
+    const results = lookupNext(istate.state, [{ parent: null, results: trueDecls }], "decls", next.property);
+    if (!results)
+        return null;
+    return results.reduce((cur, lookupDefn) => {
+        unionInto(cur, typeFromTypeStateNodes(istate.state, lookupDefn.results));
+        return cur;
+    }, { type: 0 /* TypeTag.Never */ });
+}
+function resolveDottedMember(istate, object, next) {
+    const [objDecls, trueDecls] = findObjectDeclsByProperty(istate.state, object, next);
+    if (!objDecls)
+        return null;
+    const property = findNextObjectType(istate, trueDecls, next);
+    if (!property)
+        return null;
+    const type = refineObjectTypeByDecls(istate, object, objDecls);
+    const mayThrow = !subtypeOf(object, type);
+    return { mayThrow, object: type, property };
+}
 
 
 /***/ }),
@@ -11025,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) {
@@ -11045,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);
@@ -11062,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;
@@ -11078,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;
@@ -11087,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);
                     }
@@ -11110,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 &&
@@ -11155,7 +12073,7 @@ function cleanupUnusedVars(state, node) {
                     j = i;
                     continue;
                 }
-                if (toRemove[name]) {
+                if (activeRemove[name]) {
                     changes = true;
                     j--;
                     decl.declarations.splice(i, 1);
@@ -11180,12 +12098,18 @@ function cleanupUnusedVars(state, node) {
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* unused harmony export renameVariable */
+/* unused harmony exports renameIdentifier, renameVariable */
 /* 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);
 
 
+function renameIdentifier(ident, newName) {
+    if (!ident.original) {
+        ident.original = ident.name;
+    }
+    ident.name = newName;
+}
 function renameVariable(state, locals, declName) {
     const map = locals.map;
     if (declName) {
@@ -11377,6 +12301,7 @@ __webpack_require__.d(__webpack_exports__, {
   "getApiMapping": () => (/* binding */ getApiMapping),
   "getSuperClasses": () => (/* binding */ getSuperClasses),
   "hasProperty": () => (/* reexport */ src_ast/* hasProperty */.l$),
+  "isClassVariable": () => (/* binding */ isClassVariable),
   "isLocal": () => (/* binding */ isLocal),
   "isLookupCandidate": () => (/* binding */ isLookupCandidate),
   "isStateNode": () => (/* binding */ isStateNode),
@@ -11778,7 +12703,7 @@ function visit_resource_refs(state, doc, e) {
 function add_one_resource(state, doc, module, e) {
     let id;
     let func;
-    const varDecl = () => {
+    const makeVarDecl = (id, outer) => {
         const loc = id && (0,src_ast/* adjustLoc */.b5)(id.value.loc);
         return (0,src_ast/* wrap */.re)({
             type: "VariableDeclaration",
@@ -11801,17 +12726,24 @@ function add_one_resource(state, doc, module, e) {
                         },
                     },
                     init,
-                }, e.loc),
+                }, outer),
             ],
             kind: "var",
-        }, e.loc);
+        }, outer);
     };
+    const varDecl = () => makeVarDecl(id, e.loc);
     const classDecl = (parent) => {
         if (!id)
             return null;
         const loc = id.value.loc;
         const items = init
-            ? [{ type: "ClassElement", item: varDecl(), loc: e.loc }]
+            ? [
+                {
+                    type: "ClassElement",
+                    item: makeVarDecl(undefined, init.loc),
+                    loc: e.loc,
+                },
+            ]
             : [];
         return {
             type: "ClassDeclaration",
@@ -11825,7 +12757,9 @@ function add_one_resource(state, doc, module, e) {
         if (!id)
             return null;
         const loc = id.value.loc;
-        const items = init ? [varDecl()] : [];
+        const items = init
+            ? [makeVarDecl(undefined, init.loc)]
+            : [];
         return {
             type: "FunctionDeclaration",
             body: { type: "BlockStatement", body: items, loc: e.loc },
@@ -11917,8 +12851,10 @@ function add_one_resource(state, doc, module, e) {
     if (!func)
         return;
     const elements = visit_resource_refs(state, doc, e);
+    const startLoc = elements[0]?.loc;
+    const endLoc = elements[elements.length - 1]?.loc;
     const init = elements.length
-        ? { type: "ArrayExpression", elements }
+        ? (0,src_ast/* wrap */.re)({ type: "ArrayExpression", elements }, startLoc && endLoc && (0,src_ast/* locRange */.ht)(startLoc, endLoc))
         : undefined;
     if (!id) {
         if (!init)
@@ -11930,8 +12866,8 @@ function add_one_resource(state, doc, module, e) {
     }
 }
 
-// EXTERNAL MODULE: ./src/type-flow.ts
-var type_flow = __webpack_require__(4859);
+// EXTERNAL MODULE: ./src/type-flow/type-flow-util.ts
+var type_flow_util = __webpack_require__(1638);
 // EXTERNAL MODULE: ./src/type-flow/types.ts
 var types = __webpack_require__(7255);
 // EXTERNAL MODULE: external "./util.cjs"
@@ -12564,7 +13500,7 @@ function lookupWithType(state, node, typeMap, nonLocal = false, stack = null) {
         const objectType = typeMap.get(node.object);
         if (!objectType)
             return results;
-        const [, decls] = (0,type_flow/* findObjectDeclsByProperty */.nK)(state, objectType, node);
+        const [, decls] = (0,type_flow_util/* findObjectDeclsByProperty */.nK)(state, objectType, node);
         if (decls) {
             const next = lookupNext(state, [{ parent: null, results: decls }], "decls", node.property);
             if (next) {
@@ -13099,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$&")
@@ -13304,6 +14241,9 @@ function markInvokeClassMethod(state, func) {
 function isLocal(v) {
     return v.stack[v.stack.length - 1]?.sn.type === "BlockStatement";
 }
+function isClassVariable(v) {
+    return v.stack[v.stack.length - 1]?.sn.type === "ClassDeclaration";
+}
 function diagnostic(state, node, message, type = "INFO", extra) {
     if (!state.diagnostics)
         state.diagnostics = {};