@markw65/monkeyc-optimizer 1.1.8 → 1.1.10

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__ = ({
 
@@ -1846,7 +1846,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, 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);
@@ -2725,10 +2725,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);
+
 
 
 
@@ -3180,7 +3182,12 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
         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 +3277,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 +3337,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 +3372,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);
                             }
                         }
                     }
@@ -3483,7 +3490,7 @@ async function optimizeMonkeyC(fnMap, resourcesMap, manifestXML, config) {
                 break;
             case "BlockStatement":
             case "ForStatement":
-                if (locals.map && cleanupUnusedVars(state, node)) {
+                if (locals.map && cleanupUnusedVars(state, node) && !state.inlining) {
                     again = true;
                 }
                 break;
@@ -3529,9 +3536,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;
@@ -3799,6 +3811,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);
             }
         }
@@ -3971,7 +3984,9 @@ function pragmaChecker(state, ast, diagnostics) {
         if (node.start && node.start >= (comment.end || Infinity)) {
             const { kind, quote, needle } = matchers.shift();
             if (kind === "match") {
-                const haystack = formatAst(node).replace(/([\r\n]|\s)+/g, " ");
+                const haystack = formatAst(node)
+                    .replace(/([\r\n]|\s)+/g, " ")
+                    .replace(/\b\w+\s\/\*>(\w+)<\*\//g, "$1");
                 if (!matcher(quote, needle, haystack)) {
                     matcher(quote, needle, haystack);
                     diagnostic(state, comment, `Didn't find '${needle}' in '${haystack}'`, "ERROR");
@@ -3989,7 +4004,7 @@ function pragmaChecker(state, ast, diagnostics) {
                     }
                     if (a.end.line > b.end.line)
                         return 1;
-                    if (a.end.line === b.end.line && a.end.column >= b.end.column) {
+                    if (a.end.line === b.end.line && a.end.column > b.end.column) {
                         return 1;
                     }
                     return 0;
@@ -4044,8 +4059,10 @@ function pragmaChecker(state, ast, diagnostics) {
 /* 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 _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_minimize_locals__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(736);
+/* 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__);
+
 
 
 
@@ -4150,6 +4167,7 @@ function sizeBasedPRE(state, func) {
         applyReplacements(func.node, nodeMap, declMap);
         func.node.body.body.unshift(variableDecl);
     }
+    minimizeLocals(state, func);
 }
 function buildPREGraph(state, func) {
     const result = buildDataFlowGraph(state, func, (literal) => refCost(literal) > LocalRefCost, true, false);
@@ -4297,11 +4315,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:
@@ -4797,26 +4816,30 @@ 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, 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 _optimizer_types__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(9697);
+/* harmony import */ var _type_flow_could_be__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(4055);
+/* harmony import */ var _type_flow_dead_store__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(8486);
+/* harmony import */ var _type_flow_interp__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(7161);
+/* harmony import */ var _type_flow_interp_call__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(2222);
+/* harmony import */ var _type_flow_intersection_type__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(6973);
+/* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(9234);
+/* harmony import */ var _type_flow_type_flow_util__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(1638);
+/* harmony import */ var _type_flow_types__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(7255);
+/* harmony import */ var _type_flow_union_type__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(757);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(6906);
+/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_16___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_16__);
+
+
+
 
 
 
@@ -4836,10 +4859,20 @@ const logging = true;
 // To avoid over zealous optimizations, we don't optimize
 // away any Null checks for now.
 const missingNullWorkaround = true;
+function loggingEnabledFor(env, func) {
+    const pattern = process.env[env];
+    if (!pattern)
+        return false;
+    const match = pattern.match(/^\/(.*)\/(i?)$/);
+    if (match) {
+        return new RegExp(match[1], match[2]).test(func.fullName);
+    }
+    return pattern === func.fullName;
+}
 function buildTypeInfo(state, func, optimizeEquivalencies) {
     if (!func.node.body || !func.stack)
         return;
-    const logThisRun = logging && process.env["TYPEFLOW_FUNC"] === func.fullName;
+    const logThisRun = logging && loggingEnabledFor("TYPEFLOW_FUNC", func);
     while (true) {
         const { graph } = buildDataFlowGraph(state, func, () => false, false, true);
         if (optimizeEquivalencies &&
@@ -4850,9 +4883,18 @@ function buildTypeInfo(state, func, optimizeEquivalencies) {
              */
             continue;
         }
-        return propagateTypes({ ...state, stack: func.stack }, func, graph, optimizeEquivalencies, logThisRun);
+        return propagateTypes({ ...state, stack: func.stack }, func, graph, optimizeEquivalencies, logThisRun).istate;
     }
 }
+function buildConflictGraph(state, func) {
+    if (!func.node.body || !func.stack)
+        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);
+    return { graph, localConflicts, locals, identifiers, logThisRun };
+}
 function addEquiv(ts, key, equiv) {
     if (key === equiv)
         return true;
@@ -4956,36 +4998,101 @@ 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, ...rest } = blockState;
+    const clone = { map: new Map(map), ...rest };
+    if (trackedMemberDecls) {
+        clone.trackedMemberDecls = new Map();
+        trackedMemberDecls.forEach((value, key) => {
+            clone.trackedMemberDecls.set(key, new Map(value));
+        });
+    }
+    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 Map([[key, new Set([assocKey])]]));
+            return;
+        }
+        const entry = entries.get(key);
+        if (!entry) {
+            entries.set(key, new Set([assocKey]));
+            return;
+        }
+        entry.add(assocKey);
+    });
+}
+function mergeTypeState(blockStates, index, from) {
     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 this from scratch via
+    // addTrackedMemberDecl below.
+    delete to.trackedMemberDecls;
     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.get(k);
+                tov = to.map.get(k);
             }
         }
+        if (tov.assocPaths) {
+            const assocPaths = new Set(tov.assocPaths);
+            tov = { ...tov };
+            if (!fromv.assocPaths) {
+                changes = true;
+                delete tov.assocPaths;
+            }
+            else {
+                assocPaths.forEach((key) => {
+                    if (!fromv.assocPaths.has(key)) {
+                        assocPaths.delete(key);
+                    }
+                    else {
+                        addTrackedMemberDecl(to, k, key);
+                    }
+                });
+                tov.assocPaths = assocPaths;
+            }
+            to.map.set(k, tov);
+        }
         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;
             }
@@ -4998,7 +5105,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;
@@ -5025,149 +5132,91 @@ 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((paths, key) => {
+        const entry = blockState.map.get(key);
+        assert(entry);
+        let newEntry = entry;
+        paths.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()];
+            assert(entry.assocPaths?.has(path));
+            const assocPath = [];
+            const pathSegments = path.split(".");
+            let type = entry.curType;
+            for (let i = 0; i < pathSegments.length; i++) {
+                const pathItem = pathSegments[i];
+                assocPath.push({
+                    name: pathItem === "*" ? null : pathItem,
+                    type,
+                });
+                if (pathItem === affectedName && couldBeShallow(type, objectType)) {
+                    const newAssocKey = assocPath.map((av) => av.name ?? "*").join(".");
+                    const baseType = updateByAssocPath(assocPath, assignedType, true);
+                    if (newEntry === entry) {
+                        newEntry = { ...entry };
+                    }
+                    newEntry.curType = baseType;
+                    if (path !== newAssocKey) {
+                        newEntry.assocPaths = new Set(entry.assocPaths);
+                        newEntry.assocPaths.delete(path);
+                        newEntry.assocPaths.add(newAssocKey);
+                        const newPaths = new Set(paths);
+                        newPaths.delete(path);
+                        newPaths.add(newAssocKey);
+                        affected.set(key, newPaths);
+                    }
+                    break;
                 }
-                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;
-                            }
+                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);
                         }
-                    });
-                });
-                d = d.flatMap((d) => {
-                    if (d.type !== "ClassDeclaration" ||
-                        !d.superClass ||
-                        d.superClass === true) {
-                        return [];
                     }
-                    return d.superClass;
-                });
-            } while (d.length);
+                    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) {
+            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) {
     // 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;
     });
@@ -5181,7 +5230,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
     function memberDeclInfo(blockState, decl, clearEquiv, 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();
@@ -5252,55 +5301,64 @@ 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, false);
+        // setStateEvent guarantees that tsv is "unshared" at this
+        // point. So we can munge it directly.
+        const tsv = blockState.map.get(decl.base);
+        if (!tsv.assocPaths)
+            tsv.assocPaths = new Set();
+        tsv.assocPaths.add(assocKey);
+        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, false);
+                            };
+                            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) {
@@ -5320,29 +5378,35 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
     function setStateEvent(blockState, decl, value, clearEquiv) {
         if (Array.isArray(decl) ||
             (decl.type !== "MemberDecl" && decl.type !== "Unknown")) {
+            const v = { ...blockState.map.get(decl) };
             if (!clearEquiv) {
                 /*
                  * If we're not clearing the equivalencies then this update
                  * must be applied to every element of the set
                  */
-                const v = blockState.get(decl);
-                if (v?.equivSet) {
+                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 {
-                removeEquiv(blockState, decl);
+                removeEquiv(blockState.map, decl);
+                delete v.equivSet;
+                if (v.assocPaths?.size) {
+                    clearAssocPaths(blockState, decl, v);
+                    delete v.assocPaths;
+                }
             }
-            blockState.set(decl, { curType: value });
+            v.curType = value;
+            blockState.map.set(decl, v);
             return;
         }
         if (decl.type === "Unknown") {
@@ -5356,10 +5420,10 @@ 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;
         }
@@ -5370,7 +5434,6 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
         return { curType: info ? info[0] : { type: 524287 /* TypeTag.Any */ } };
     }
     const blockStates = [];
-    const blockVisits = [];
     const typeMap = new Map();
     const istate = {
         state,
@@ -5388,7 +5451,7 @@ 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)) {
                 queue.enqueue(succ);
             }
         });
@@ -5423,7 +5486,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         return false;
                     }
                 }
-                const tmpState = new Map(curState);
+                const tmpState = cloneTypeState(curState);
                 setStateEvent(tmpState, leftDecl, leftr, false);
                 if (rightDecl) {
                     let rightr = restrictByEquality(left, right);
@@ -5449,7 +5512,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 singletonRemoved.type -= right.type;
                 if (singletonRemoved.type === 0 /* TypeTag.Never */)
                     return false;
-                const tmpState = new Map(curState);
+                const tmpState = cloneTypeState(curState);
                 setStateEvent(tmpState, leftDecl, singletonRemoved, false);
                 return tmpState;
             }
@@ -5481,7 +5544,7 @@ 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);
+                            const tmpState = cloneTypeState(curState);
                             setStateEvent(tmpState, event.left, singletonRemoved, false);
                             return tmpState;
                         }
@@ -5496,7 +5559,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         });
                         if (nonNullRemoved.type === 0 /* TypeTag.Never */)
                             return false;
-                        const tmpState = new Map(curState);
+                        const tmpState = cloneTypeState(curState);
                         setStateEvent(tmpState, event.left, nonNullRemoved, false);
                         return tmpState;
                     }
@@ -5554,7 +5617,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         }
                     }
                     if (result) {
-                        const tmpState = new Map(curState);
+                        const tmpState = cloneTypeState(curState);
                         setStateEvent(tmpState, event.left, result, false);
                         return tmpState;
                     }
@@ -5582,7 +5645,7 @@ 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)) {
                 queue.enqueue(trueSucc);
             }
         }
@@ -5594,7 +5657,7 @@ 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)) {
                 queue.enqueue(falseSucc);
             }
         }
@@ -5606,7 +5669,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
     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)) {
                 queue.enqueue(top.exsucc);
             }
         }
@@ -5614,9 +5677,12 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             case "kil": {
                 const curEntry = getStateEntry(curState, event.decl);
                 if (curEntry.equivSet) {
-                    removeEquiv(curState, event.decl);
+                    removeEquiv(curState.map, event.decl);
+                }
+                if (curEntry.assocPaths) {
+                    clearAssocPaths(curState, event.decl, curEntry);
                 }
-                curState.delete(event.decl);
+                curState.map.delete(event.decl);
                 break;
             }
             case "ref": {
@@ -5624,7 +5690,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                 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,
@@ -5659,23 +5725,32 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
                         break;
                     }
                 }
-                curState.forEach((tsv, decl) => {
+                curState.map.forEach((tsv, decl) => {
                     let type = tsv.curType;
-                    if (callees === undefined || modifiableDecl(decl, callees)) {
+                    if (!some(decl, (d) => d.type === "VariableDeclarator" &&
+                        (d.node.kind === "var" ||
+                            // even a "const" could have its "inner" type altered
+                            (type.value != null && (type.type & 32768 /* TypeTag.Object */) !== 0)))) {
+                        return;
+                    }
+                    if (modifiableDecl(decl, callees)) {
                         if (tsv.equivSet) {
-                            removeEquiv(curState, decl);
+                            removeEquiv(curState.map, decl);
+                        }
+                        if (tsv.assocPaths) {
+                            clearAssocPaths(curState, decl, tsv);
                         }
-                        curState.set(decl, { curType: typeConstraint(decl) });
+                        curState.map.set(decl, { curType: typeConstraint(decl) });
                     }
                     else if (type.value != null &&
-                        !every(callees, (callee) => callee.info === false)) {
+                        (!callees || !every(callees, (callee) => callee.info === false))) {
                         if (type.type & 32768 /* TypeTag.Object */) {
                             const odata = getObjectValue(tsv.curType);
                             if (odata?.obj) {
                                 type = cloneType(type);
                                 const newData = { klass: odata.klass };
                                 setUnionComponent(type, 32768 /* TypeTag.Object */, newData);
-                                curState.set(decl, { ...tsv, curType: type });
+                                curState.map.set(decl, { ...tsv, curType: type });
                             }
                         }
                     }
@@ -5700,23 +5775,43 @@ 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, true);
+                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);
+                            }
+                            if (value.assocPaths) {
+                                clearAssocPaths(curState, decls, value);
                             }
-                            curState.set(decls, { curType: typeConstraint(decls) });
+                            curState.map.set(decls, { curType: typeConstraint(decls) });
                         }
                     });
                 }
                 if (event.rhs) {
-                    const selfAssign = addEquiv(curState, event.rhs, event.decl);
+                    const selfAssign = addEquiv(curState.map, event.rhs, event.decl);
                     if (event.node.type === "AssignmentExpression") {
                         if (selfAssign) {
                             // rhs and lhs are identical
@@ -5735,7 +5830,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);
                             }
                         });
@@ -5756,7 +5852,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))}`);
@@ -5768,7 +5864,7 @@ 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) => {
@@ -5784,7 +5880,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);
@@ -5828,7 +5924,7 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
     }
     if (optimizeEquivalencies) {
         if (!nodeEquivs.size && !selfAssignments.size) {
-            return istate;
+            return { istate, nodeEquivs };
         }
         if (logThisRun) {
             if (selfAssignments.size) {
@@ -5928,7 +6024,58 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
             return replacement;
         });
     }
-    return istate;
+    return { istate, nodeEquivs };
+}
+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;
 }
 
 
@@ -5938,7 +6085,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);
@@ -5956,7 +6103,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) {
@@ -5976,7 +6123,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;
             }
@@ -6026,12 +6173,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 */:
@@ -6047,10 +6201,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 &&
@@ -6076,7 +6231,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 &&
@@ -6106,12 +6261,12 @@ function couldBeObj(a, b) {
 
 "use strict";
 /* unused harmony exports findDeadStores, eliminateDeadStores */
-/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6652);
-/* harmony import */ var _inliner__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(333);
-/* 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 _control_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5101);
-/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8180);
+/* 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);
 
 
@@ -6119,12 +6274,13 @@ function couldBeObj(a, b) {
 
 
 
-function findDeadStores(graph, logThisRun) {
+function findDeadStores(func, graph, nodeEquivs, logThisRun) {
     const order = getPostOrder(graph);
     order.forEach((block, i) => {
         block.order = i;
     });
     const blockStates = [];
+    const nodeConflicts = nodeEquivs && new Map();
     const mergeStates = (to, from) => {
         return Array.from(to).reduce((changed, decl) => {
             if (!from.has(decl)) {
@@ -6135,11 +6291,13 @@ function findDeadStores(graph, logThisRun) {
         }, false);
     };
     const queue = new DataflowQueue();
-    const locals = new Set(order.flatMap((block) => block.events
+    const locals = new Set(order
+        .flatMap((block) => block.events
         ? block.events
             .filter((event) => event.type === "def" && declIsLocal(event.decl))
             .map((def) => def.decl)
-        : []));
+        : [])
+        .concat(func.node.params));
     const deadStores = new Set();
     order.forEach((block) => {
         if (!block.succs) {
@@ -6180,13 +6338,34 @@ function findDeadStores(graph, logThisRun) {
                         }
                         break;
                     case "def":
-                        if (isTypeStateKey(event.decl)) {
+                        if (isTypeStateKey(event.decl) &&
+                            (event.node.type !== "VariableDeclarator" || event.node.init)) {
                             if (curState.has(event.decl)) {
                                 deadStores.add(event.node);
                             }
                             else {
                                 deadStores.delete(event.node);
                             }
+                            if (nodeConflicts) {
+                                const conflicts = new Set(locals);
+                                curState.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;
+                                    if (equiv) {
+                                        equiv.equiv.forEach((e) => isTypeStateKey(e) && conflicts.delete(e));
+                                        isTypeStateKey(equiv.decl) && conflicts.delete(equiv.decl);
+                                    }
+                                }
+                                conflicts.add(event.decl);
+                                nodeConflicts.set(event.node, conflicts);
+                            }
                             if ((event.node.type === "AssignmentExpression" &&
                                 event.node.operator === "=") ||
                                 (event.node.type === "VariableDeclarator" && event.node.init)) {
@@ -6231,10 +6410,27 @@ function findDeadStores(graph, logThisRun) {
             doMerge(top.bogopred);
         }
     }
-    return deadStores;
+    let localConflicts = null;
+    if (nodeConflicts) {
+        localConflicts = new Map();
+        const addConflicts = (conflict, conflicts) => {
+            let set = localConflicts.get(conflict);
+            if (set) {
+                conflicts.forEach((c) => c !== conflict && set.add(c));
+            }
+            else {
+                set = new Set(conflicts);
+                set.delete(conflict);
+                localConflicts.set(conflict, set);
+            }
+        };
+        nodeConflicts.forEach((conflicts) => conflicts.forEach((conflict) => addConflicts(conflict, conflicts)));
+        func.node.params.forEach((param, index, arr) => addConflicts(param, arr));
+    }
+    return { deadStores, locals, localConflicts };
 }
 function eliminateDeadStores(state, func, graph, logThisRun) {
-    const deadStores = findDeadStores(graph, logThisRun);
+    const { deadStores } = findDeadStores(func, graph, null, logThisRun);
     if (!deadStores.size)
         return false;
     if (logThisRun) {
@@ -6722,15 +6918,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);
 
 
 
@@ -7205,11 +7401,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);
 
@@ -8504,35 +8700,329 @@ function restrictByEqualityByComponent(a, b) {
                 br = cloneType(brt);
             }
             else {
-                unionInto(br, brt);
+                unionInto(br, brt);
+            }
+        }
+        bits = next;
+    } while (bits);
+    if (!br) {
+        return { type: 0 /* TypeTag.Never */ };
+    }
+    return br;
+}
+/*
+ * Given that a == b, reutnr what we can deduce about b's
+ * type.
+ *
+ * Note that this is similar to intersection. In many cases, it
+ * is intersection. eg if a is the type (Null or "Hello" or Menu)
+ * then we know b's type must be a subtype of intersection(a, b).
+ *
+ * But eg if it was a == 5, and a is known to be Char, String,
+ * Number or Float, we can only eliminate String, because
+ * 5.0 == 5, and 5.toChar() == 5.
+ */
+function restrictByEquality(a, b) {
+    if (a.type === 0 /* TypeTag.Never */)
+        return a;
+    if (isExact(a)) {
+        return restrictExactTypesByEquality(a, b);
+    }
+    return restrictByEqualityByComponent(a, b);
+}
+
+
+/***/ }),
+
+/***/ 736:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* 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 _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 _variable_renamer__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4405);
+/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1638);
+
+
+
+
+
+
+
+function minimizeLocals(state, func) {
+    const result = buildConflictGraph(state, func);
+    if (!result)
+        return;
+    const { graph, localConflicts, locals: localSet, identifiers, logThisRun, } = result;
+    if (!localConflicts)
+        return;
+    const colors = new Map();
+    const locals = Array.from(localSet)
+        .sort((a, b) => (localConflicts.get(a)?.size ?? 0) - (localConflicts.get(b)?.size ?? 0))
+        .filter((key) => key.type === "VariableDeclarator" ||
+        key.type === "Identifier" ||
+        key.type === "BinaryExpression");
+    const merge = [];
+    locals.forEach((local) => {
+        let inUse = 0n;
+        localConflicts.get(local)?.forEach((conflict) => {
+            const color = colors.get(conflict);
+            if (color != null) {
+                inUse |= 1n << BigInt(color);
+            }
+        });
+        let lowest = 0;
+        while (inUse & 1n) {
+            lowest++;
+            inUse >>= 1n;
+        }
+        colors.set(local, lowest);
+        if (!merge[lowest]) {
+            merge[lowest] = [local];
+        }
+        else {
+            merge[lowest].push(local);
+        }
+    });
+    const didMerge = merge.some((merged) => merged.length > 1);
+    if (didMerge !== (merge.length !== locals.length)) {
+        throw new Error("WTF?");
+    }
+    if (!didMerge)
+        return;
+    if (logThisRun) {
+        console.log(`>>> Merging locals in ${func.fullName}`);
+        merge.forEach((merged) => merged.length > 1 &&
+            console.log(` - merging ${merged.map((k) => tsKey(k)).join(" | ")}`));
+    }
+    const remap = new Map();
+    merge.forEach((merged) => {
+        if (merged.length === 1)
+            return;
+        const info = merged.reduce((cur, decl) => {
+            if (decl.type === "Identifier" || decl.type === "BinaryExpression") {
+                return {
+                    decl,
+                    stack: func.stack,
+                    depth: func.stack.length,
+                    name: variableDeclarationName(decl),
+                };
+            }
+            if (cur === null) {
+                return {
+                    decl,
+                    stack: decl.stack,
+                    depth: decl.stack.length,
+                    name: decl.name,
+                };
+            }
+            let depth = cur.depth < decl.stack.length ? cur.depth : decl.stack.length;
+            while (true) {
+                if (cur.stack[depth - 1].sn === decl.stack[depth - 1].sn) {
+                    break;
+                }
+                depth--;
+            }
+            if (cur.stack.length > decl.stack.length) {
+                return { decl, stack: decl.stack, depth, name: decl.name };
+            }
+            cur.depth = depth;
+            return cur;
+        }, null);
+        assert(info);
+        merged.forEach((decl) => remap.set(decl, info));
+        if (info.decl.type === "VariableDeclarator") {
+            let name = info.name;
+            if (locals.some((local) => local !== info.decl &&
+                local.type === "VariableDeclarator" &&
+                local.name === name)) {
+                // There's a variable in another scope with the same name, so
+                // produce a new one.
+                let i = 0;
+                do {
+                    name = `${info.decl.name}_${i++}`;
+                } while (identifiers.has(name));
+                identifiers.add(name);
+                info.name = name;
+            }
+            let depth = info.depth - 1;
+            let sn = info.stack[depth].sn;
+            while (true) {
+                assert(sn.type === "BlockStatement");
+                if (sn.node.type !== "ForStatement") {
+                    break;
+                }
+                sn = info.stack[--depth].sn;
+            }
+            const varDecl = {
+                type: "VariableDeclarator",
+                kind: "var",
+                id: { type: "Identifier", name },
+            };
+            if (sn.node.body.length &&
+                sn.node.body[0].type === "VariableDeclaration") {
+                sn.node.body[0].declarations.unshift(withLocDeep(varDecl, sn.node.body[0], false, true));
+            }
+            else {
+                sn.node.body.unshift(withLocDeep({
+                    type: "VariableDeclaration",
+                    declarations: [varDecl],
+                    kind: "var",
+                }, sn.node, false, true));
             }
         }
-        bits = next;
-    } while (bits);
-    if (!br) {
-        return { type: 0 /* TypeTag.Never */ };
-    }
-    return br;
-}
-/*
- * Given that a == b, reutnr what we can deduce about b's
- * type.
- *
- * Note that this is similar to intersection. In many cases, it
- * is intersection. eg if a is the type (Null or "Hello" or Menu)
- * then we know b's type must be a subtype of intersection(a, b).
- *
- * But eg if it was a == 5, and a is known to be Char, String,
- * Number or Float, we can only eliminate String, because
- * 5.0 == 5, and 5.toChar() == 5.
- */
-function restrictByEquality(a, b) {
-    if (a.type === 0 /* TypeTag.Never */)
-        return a;
-    if (isExact(a)) {
-        return restrictExactTypesByEquality(a, b);
-    }
-    return restrictByEqualityByComponent(a, b);
+    });
+    const order = getPostOrder(graph);
+    const nodeMap = new Map();
+    order.forEach((block) => block.events?.forEach((event) => {
+        if ((event.type !== "ref" && event.type !== "def") ||
+            !isTypeStateKey(event.decl) ||
+            !localSet.has(event.decl)) {
+            return;
+        }
+        const rep = remap.get(event.decl);
+        if (!rep)
+            return;
+        nodeMap.set(event.node, rep);
+    }));
+    traverseAst(func.node.body, null, (node) => {
+        const info = nodeMap.get(node);
+        switch (node.type) {
+            case "Identifier":
+                if (info && info.name !== node.name) {
+                    renameIdentifier(node, info.name);
+                }
+                return null;
+            case "AssignmentExpression":
+                if (info) {
+                    assert(node.left.type === "Identifier");
+                    if (node.right.type === "Identifier" &&
+                        node.right.name === info.name) {
+                        return withLoc({ type: "Literal", value: null, raw: "null" }, node, node);
+                    }
+                    if (node.left.name !== info.name) {
+                        renameIdentifier(node.left, info.name);
+                    }
+                    return null;
+                }
+                break;
+            case "ExpressionStatement":
+                if (node.expression.type === "Literal") {
+                    return false;
+                }
+                break;
+            case "UpdateExpression":
+                if (info) {
+                    assert(node.argument.type === "Identifier");
+                    if (node.argument.name !== info.name) {
+                        renameIdentifier(node.argument, info.name);
+                    }
+                    return null;
+                }
+                break;
+            case "VariableDeclarator":
+                if (info) {
+                    if (!node.init) {
+                        return false; // delete this entry
+                    }
+                    if (node.init.type === "Identifier" && node.init.name === info.name) {
+                        // this would create a self assignment, so just drop it
+                        return false;
+                    }
+                    // VariableDeclarations aren't allowed to have
+                    // AssignmentExpressions in them, but we'll fix that
+                    // below
+                    return withLoc({
+                        type: "AssignmentExpression",
+                        operator: "=",
+                        left: withLoc({
+                            type: "Identifier",
+                            name: info.name,
+                            original: variableDeclarationName(node.id),
+                        }, node.id, node.id),
+                        right: node.init,
+                    }, node, node);
+                }
+                break;
+            case "VariableDeclaration":
+                if (node.declarations.some((decl) => decl.type !== "VariableDeclarator")) {
+                    const results = [];
+                    node.declarations.forEach((decl) => {
+                        if (isExpression(decl)) {
+                            results.push(withLoc({ type: "ExpressionStatement", expression: decl }, decl, decl));
+                        }
+                        else if (decl.init) {
+                            results.push(withLoc({
+                                type: "ExpressionStatement",
+                                expression: withLoc({
+                                    type: "AssignmentExpression",
+                                    operator: "=",
+                                    left: withLoc({
+                                        type: "Identifier",
+                                        name: variableDeclarationName(decl.id),
+                                    }, decl.id, decl.id),
+                                    right: decl.init,
+                                }, decl, decl),
+                            }, decl, decl));
+                        }
+                    });
+                    node.declarations = node.declarations.filter((decl) => {
+                        if (decl.type === "VariableDeclarator") {
+                            delete decl.init;
+                            return true;
+                        }
+                        return false;
+                    });
+                    if (node.declarations.length) {
+                        withLocDeep(node, node, false);
+                        results.unshift(node);
+                    }
+                    // if this was the init of a ForStatement, this will
+                    // replace its init with a BlockStatement, so we have to
+                    // fix that below.
+                    return results;
+                }
+                break;
+            case "ForStatement":
+                if (node.init) {
+                    if (node.init.type === "BlockStatement") {
+                        const result = node.init;
+                        delete node.init;
+                        result.body.push(node);
+                        if (node.loc && result.loc) {
+                            // result has the range of the original VariableDeclaration
+                            // but now we're moving that ahead of the 'for', so to keep
+                            // things straight, we need to set the for's start to be
+                            // where result ended, and result's end to be where the for
+                            // ends (since that block now encloses the for)
+                            node.start = result.end;
+                            node.loc.start = result.loc.end;
+                            result.end = node.end;
+                            result.loc.end = node.loc.end;
+                        }
+                        return result;
+                    }
+                    if (node.init.type === "Literal") {
+                        delete node.init;
+                    }
+                }
+                break;
+            case "SequenceExpression":
+                if (node.expressions.some((e) => e.type === "Literal")) {
+                    node.expressions = node.expressions.filter((e) => e.type !== "Literal");
+                }
+                break;
+        }
+        assert(!info);
+        return null;
+    });
+    return;
 }
 
 
@@ -9319,12 +9809,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, 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);
+
+
+
+
 
 
 
@@ -9401,6 +9902,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 };
+}
 
 
 /***/ }),
@@ -10820,12 +11455,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) {
@@ -10917,6 +11558,14 @@ module.exports = require("@markw65/prettier-plugin-monkeyc");
 "use strict";
 module.exports = require("fs/promises");
 
+/***/ }),
+
+/***/ 4143:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:assert");
+
 /***/ })
 
 /******/ 	});
@@ -11009,6 +11658,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),
@@ -11410,7 +12060,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",
@@ -11433,17 +12083,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",
@@ -11457,7 +12114,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 },
@@ -11549,8 +12208,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)
@@ -11562,8 +12223,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"
@@ -12196,7 +12857,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) {
@@ -12936,6 +13597,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 = {};