@markw65/monkeyc-optimizer 1.1.9 → 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);
                             }
                         }
                     }
@@ -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);
             }
         }
@@ -4302,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:
@@ -4802,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, buildConflictGraph, resolveDottedMember */
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6817);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6652);
-/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5101);
-/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8180);
-/* harmony import */ var _function_info__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(819);
-/* harmony import */ var _type_flow_dead_store__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(8486);
-/* harmony import */ var _type_flow_interp__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(7161);
-/* harmony import */ var _type_flow_interp_call__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(2222);
-/* harmony import */ var _type_flow_intersection_type__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(6973);
-/* harmony import */ var _type_flow_sub_type__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(9234);
-/* harmony import */ var _type_flow_type_flow_util__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(1638);
-/* harmony import */ var _type_flow_types__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(7255);
-/* harmony import */ var _type_flow_union_type__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(757);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(6906);
-/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(_util__WEBPACK_IMPORTED_MODULE_13__);
+/* unused harmony exports missingNullWorkaround, buildTypeInfo, buildConflictGraph */
+/* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4143);
+/* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(node_assert__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6652);
+/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5101);
+/* harmony import */ var _data_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8180);
+/* harmony import */ var _function_info__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(819);
+/* harmony import */ var _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__);
+
+
+
 
 
 
@@ -4980,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;
             }
@@ -5022,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;
@@ -5049,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;
     });
@@ -5205,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();
@@ -5276,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) {
@@ -5344,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") {
@@ -5380,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;
         }
@@ -5394,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,
@@ -5412,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);
             }
         });
@@ -5447,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);
@@ -5473,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;
             }
@@ -5505,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;
                         }
@@ -5520,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;
                     }
@@ -5578,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;
                     }
@@ -5606,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);
             }
         }
@@ -5618,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);
             }
         }
@@ -5630,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);
             }
         }
@@ -5638,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": {
@@ -5648,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,
@@ -5683,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 });
                             }
                         }
                     }
@@ -5724,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
@@ -5759,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);
                             }
                         });
@@ -5780,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))}`);
@@ -5792,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) => {
@@ -5808,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);
@@ -5954,6 +6026,57 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, logThisRun) {
     }
     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;
+}
 
 
 /***/ }),
@@ -5962,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);
@@ -5980,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) {
@@ -6000,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;
             }
@@ -6050,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 */:
@@ -6071,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 &&
@@ -6100,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 &&
@@ -6787,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);
 
 
 
@@ -7270,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);
 
@@ -8610,12 +8741,14 @@ function restrictByEquality(a, b) {
 /* unused harmony export minimizeLocals */
 /* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4143);
 /* harmony import */ var node_assert__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(node_assert__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5101);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6817);
-/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6652);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6817);
+/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_api__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _ast__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6652);
+/* harmony import */ var _control_flow__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5101);
 /* harmony import */ var _type_flow__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4859);
-/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(1638);
+/* harmony import */ var _variable_renamer__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4405);
+/* harmony import */ var _type_flow_util__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1638);
+
 
 
 
@@ -8763,8 +8896,7 @@ function minimizeLocals(state, func) {
         switch (node.type) {
             case "Identifier":
                 if (info && info.name !== node.name) {
-                    node.original = node.name;
-                    node.name = info.name;
+                    renameIdentifier(node, info.name);
                 }
                 return null;
             case "AssignmentExpression":
@@ -8775,8 +8907,7 @@ function minimizeLocals(state, func) {
                         return withLoc({ type: "Literal", value: null, raw: "null" }, node, node);
                     }
                     if (node.left.name !== info.name) {
-                        node.left.original = node.left.name;
-                        node.left.name = info.name;
+                        renameIdentifier(node.left, info.name);
                     }
                     return null;
                 }
@@ -8790,8 +8921,7 @@ function minimizeLocals(state, func) {
                 if (info) {
                     assert(node.argument.type === "Identifier");
                     if (node.argument.name !== info.name) {
-                        node.argument.original = node.argument.name;
-                        node.argument.name = info.name;
+                        renameIdentifier(node.argument, info.name);
                     }
                     return null;
                 }
@@ -9679,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);
+
+
+
+
 
 
 
@@ -9761,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 };
+}
 
 
 /***/ }),
@@ -11180,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) {
@@ -11377,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),
@@ -11778,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",
@@ -11801,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",
@@ -11825,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 },
@@ -11917,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)
@@ -11930,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"
@@ -12564,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) {
@@ -13304,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 = {};